Interface LLMObs

enabled

annotate

• annotate(options): void

• Sets inputs, outputs, tags, metadata, and metrics as provided for a given LLM Observability span. Note that with the exception of tags, this method will override any existing values for the provided fields.

  For example:

  llmobs.trace({ kind: 'llm', name: 'myLLM', modelName: 'gpt-4o', modelProvider: 'openai' }, () => {
   llmobs.annotate({
     inputData: [{ content: 'system prompt', role: 'system' }, { content: 'user prompt', role: 'user' }],
     outputData: { content: 'response', role: 'ai' },
     metadata: { temperature: 0.7 },
     tags: { host: 'localhost' },
     metrics: { inputTokens: 10, outputTokens: 20, totalTokens: 30 }
   })
  })
  Copy

  Parameters

  • options: AnnotationOptions

    An object containing the inputs, outputs, tags, metadata, and metrics to set on the span.

  Returns void
• annotate(span, options): void

• Parameters

  • span: undefined | export=.Span
  • options: AnnotationOptions

  Returns void

decorate

• decorate(options): any

• Decorate a function in a javascript runtime that supports function decorators. Note that this is not supported in the Node.js runtime, but is in TypeScript.

  In TypeScript, this decorator is only supported in contexts where general TypeScript function decorators are supported.

  Parameters

  • options: LLMObsNamelessSpanOptions

    Optional LLM Observability span options.

  Returns any

deregisterProcessor

• deregisterProcessor(): void

• Deregister a processor.

  Returns void

disable

• disable(): void

• Disable LLM Observability tracing.

  Returns void

enable

• enable(options): void

• Enable LLM Observability tracing.

  Parameters

  • options: LLMObsEnableOptions

  Returns void

exportSpan

• exportSpan(span?): ExportedLLMObsSpan

• Returns a representation of a span to export its span and trace IDs. If no span is provided, the current LLMObs-type span will be used.

  Parameters

  • Optional span: export=.Span

    Optional span to export.

  Returns ExportedLLMObsSpan

  An object containing the span and trace IDs.

flush

• flush(): void

• Flushes any remaining spans and evaluation metrics to LLM Observability.

  Returns void

registerProcessor

• registerProcessor(processor): void

• Register a processor to be called on each LLMObs span.

  This can be used to modify the span before it is sent to LLMObs. For example, you can modify the input/output. You can also return null to omit the span entirely from being sent to LLM Observability.

  Otherwise, if the return value from the processor is not an instance of LLMObservabilitySpan, the span will be dropped.

  To deregister the processor, call llmobs.deregisterProcessor()

  Parameters

  • processor: ((span) => null | LLMObservabilitySpan)

    A function that will be called for each span.

    • • (span): null | LLMObservabilitySpan

      • Parameters

        • span: LLMObservabilitySpan

        Returns null | LLMObservabilitySpan

  Returns void

  Throws

  If a processor is already registered.

submitEvaluation

• submitEvaluation(spanContext, options): void

• Submits a custom evaluation metric for a given span ID and trace ID.

  Parameters

  • spanContext: ExportedLLMObsSpan

    The span context of the span to submit the evaluation metric for.
  • options: EvaluationOptions

    An object containing the label, metric type, value, and tags of the evaluation metric.

  Returns void

trace

• trace<T>(options, fn): T

• Instruments a function by automatically creating a span activated on its scope.

  The span will automatically be finished when one of these conditions is met:

  • The function returns a promise, in which case the span will finish when the promise is resolved or rejected.
  • The function takes a callback as its second parameter, in which case the span will finish when that callback is called.
  • The function doesn't accept a callback and doesn't return a promise, in which case the span will finish at the end of the function execution.

  Type Parameters

  • T

  Parameters

  • options: LLMObsNamedSpanOptions

    Optional LLM Observability span options.
  • fn: ((span, done) => T)

    The function to instrument.

    • • (span, done): T

      • Parameters

        • span: export=.Span
        • done: ((error?) => void)
          • • (error?): void

            • Parameters

              • Optional error: Error

              Returns void

        Returns T

  Returns T

  The return value of the function.

wrap

• wrap<T>(options, fn): T

• Wrap a function to automatically create a span activated on its scope when it's called.

  The span will automatically be finished when one of these conditions is met:

  • The function returns a promise, in which case the span will finish when the promise is resolved or rejected.
  • The function takes a callback as its last parameter, in which case the span will finish when that callback is called.
  • The function doesn't accept a callback and doesn't return a promise, in which case the span will finish at the end of the function execution.

  Type Parameters

  • T = ((...args) => any)

  Parameters

  • options: LLMObsNamelessSpanOptions

    Optional LLM Observability span options.
  • fn: T

    The function to instrument.

  Returns T

  A new function that wraps the provided function with span creation.