Lifecycle Callbacks

interface TraceCallbacks {
  /** Called once when the trace is first created on the server (first successful flush) */
  onCreated?: (traceId: string) => void;

  /** Called after each successful flush */
  onFlushed?: (traceId: string, itemCount: number) => void;

  /** Called when a flush operation fails after retries */
  onFlushError?: (error: Error, operation: string) => void;

  /** Called when the trace is closed */
  onClosed?: (traceId: string, reason?: string) => void;

  /** Called when items are dropped (e.g., queue full) */
  onDropped?: (count: number, reason: string) => void;
}

onCreated: (traceId: string) => void

onFlushed: (traceId: string, itemCount: number) => void

onFlushError: (error: Error, operation: string) => void

onClosed: (traceId: string, reason?: string) => void

onDropped: (count: number, reason: string) => void

const client = new Client('your-api-key', {
  callbacks: {
    onCreated: (traceId) => {
      console.log('Trace created:', traceId);
    },
    onFlushError: (error, operation) => {
      console.error(`${operation} failed:`, error.message);
    }
  }
});

const trace = client.trace({
  name: 'CriticalFlow',
  callbacks: {
    onFlushed: (traceId, itemCount) => {
      metrics.increment('critical_flush', { traceId, itemCount });
    },
    onFlushError: (error, operation) => {
      alerting.send(`Critical trace flush failed: ${error.message}`);
    }
  }
});

const client = new Client('your-api-key', {
  callbacks: {
    onCreated: () => metrics.increment('mirador.traces.created'),
    onFlushed: (_, itemCount) => {
      metrics.increment('mirador.flushes.success');
      metrics.histogram('mirador.flush.item_count', itemCount);
    },
    onFlushError: (error, operation) => {
      metrics.increment('mirador.flushes.error', { operation });
    },
    onDropped: (count) => {
      metrics.increment('mirador.items.dropped', {}, count);
    }
  }
});

const client = new Client('your-api-key', {
  callbacks: {
    onFlushError: (error, operation) => {
      // Send to your error tracking service
      Sentry.captureException(error, {
        tags: { operation, source: 'mirador-sdk' }
      });
    },
    onDropped: (count, reason) => {
      Sentry.captureMessage(`Mirador SDK dropped ${count} items: ${reason}`, 'warning');
    }
  }
});

const client = new Client('your-api-key', {
  debug: true,
  callbacks: {
    onCreated: (traceId) => console.log(`[Mirador] Created: ${traceId}`),
    onFlushed: (traceId, n) => console.log(`[Mirador] Flushed ${n} items for ${traceId}`),
    onFlushError: (err, op) => console.error(`[Mirador] ${op} failed:`, err),
    onClosed: (traceId, reason) => console.log(`[Mirador] Closed: ${traceId} (${reason ?? 'no reason'})`),
    onDropped: (count, reason) => console.warn(`[Mirador] Dropped ${count}: ${reason}`)
  }
});

import { Client } from '@miradorlabs/nodejs-sdk';

const client = new Client(process.env.MIRADOR_API_KEY, {
  callbacks: {
    onCreated: (traceId) => {
      logger.info({ traceId, msg: 'Mirador trace started' });
    },
    onClosed: (traceId, reason) => {
      logger.info({ traceId, reason, msg: 'Mirador trace ended' });
    }
  }
});