Skip to main content

​
TraceStatus

The set of allowed status values for a trace. Used to indicate the outcome of a traced operation.

​
Import

import type { TraceStatus } from '@adaline/client';

​
Type Definition

type TraceStatus = 'success' | 'failure' | 'aborted' | 'cancelled' | 'pending' | 'unknown';

​
Values

ValueDescription
'success'The traced operation completed successfully.
'failure'The operation failed due to an error or exception.
'aborted'The operation was aborted before completion (e.g. timeout).
'cancelled'The operation was explicitly cancelled by the caller or user.
'pending'The operation is still in progress. Only available for traces, not spans.
'unknown'Status has not been determined. This is the default when no status is explicitly set.
The default status for a newly created trace is 'unknown'. You should update it to a terminal status ('success', 'failure', 'aborted', or 'cancelled') before calling trace.end().

​
Examples

​
Setting Status on a Trace

import { Adaline } from '@adaline/client';

const adaline = new Adaline();
const monitor = adaline.initMonitor({ projectId: 'my-project' });

const trace = monitor.logTrace({
  name: 'Chat Request',
  tags: ['chat']
});

try {
  const result = await handleRequest();
  trace.update({ status: 'success' });
} catch (error) {
  trace.update({ status: 'failure' });
} finally {
  trace.end();
}

​
Handling Cancellation and Abort

async function handleWithTimeout(signal: AbortSignal) {
  const trace = monitor.logTrace({ name: 'Timed Request' });

  try {
    const result = await fetchWithSignal(signal);
    trace.update({ status: 'success' });
    return result;
  } catch (error) {
    if (signal.aborted) {
      trace.update({ status: 'aborted' });
    } else {
      trace.update({ status: 'failure' });
    }
    throw error;
  } finally {
    trace.end();
  }
}

​
Using Pending for Long-Running Operations

const trace = monitor.logTrace({
  name: 'Batch Processing',
  tags: ['batch']
});

trace.update({ status: 'pending' });

for (const item of items) {
  await processItem(item);
}

trace.update({ status: 'success' });
trace.end();

​
Conditional Status Logic

import type { TraceStatus } from '@adaline/client';

function resolveStatus(error?: Error, cancelled?: boolean): TraceStatus {
  if (cancelled) return 'cancelled';
  if (error) return 'failure';
  return 'success';
}

trace.update({ status: resolveStatus(error, wasCancelled) });
  • Trace — class that uses TraceStatus in trace.update()
  • Monitor — creates traces via monitor.logTrace()
  • Span — uses a similar SpanStatus type (which excludes 'pending')