dd-trace 5.24.0 → 5.26.0

package/packages/dd-trace/src/debugger/devtools_client/snapshot/collector.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { collectionSizeSym, fieldCountSym } = require('./symbols')
 const session = require('../session')
 
 const LEAF_SUBTYPES = new Set(['date', 'regexp'])
@@ -14,22 +15,38 @@ module.exports = {
 // each lookup will just finish in its own time and traverse the child nodes when the event loop allows it.
 // Alternatively, use `Promise.all` or something like that, but the code would probably be more complex.
 
-async function getObject (objectId, maxDepth, depth = 0) {
+async function getObject (objectId, opts, depth = 0, collection = false) {
   const { result, privateProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
   })
 
-  if (privateProperties) result.push(...privateProperties)
+  if (collection) {
+    // Trim the collection if it's too large.
+    // Collections doesn't contain private properties, so the code in this block doesn't have to deal with it.
+    removeNonEnumerableProperties(result) // remove the `length` property
+    const size = result.length
+    if (size > opts.maxCollectionSize) {
+      result.splice(opts.maxCollectionSize)
+      result[collectionSizeSym] = size
+    }
+  } else if (result.length > opts.maxFieldCount) {
+    // Trim the number of properties on the object if there's too many.
+    const size = result.length
+    result.splice(opts.maxFieldCount)
+    result[fieldCountSym] = size
+  } else if (privateProperties) {
+    result.push(...privateProperties)
+  }
 
-  return traverseGetPropertiesResult(result, maxDepth, depth)
+  return traverseGetPropertiesResult(result, opts, depth)
 }
 
-async function traverseGetPropertiesResult (props, maxDepth, depth) {
+async function traverseGetPropertiesResult (props, opts, depth) {
   // TODO: Decide if we should filter out non-enumerable properties or not:
   // props = props.filter((e) => e.enumerable)
 
-  if (depth >= maxDepth) return props
+  if (depth >= opts.maxReferenceDepth) return props
 
   for (const prop of props) {
     if (prop.value === undefined) continue
@@ -37,33 +54,33 @@ async function traverseGetPropertiesResult (props, maxDepth, depth) {
     if (type === 'object') {
       if (objectId === undefined) continue // if `subtype` is "null"
       if (LEAF_SUBTYPES.has(subtype)) continue // don't waste time with these subtypes
-      prop.value.properties = await getObjectProperties(subtype, objectId, maxDepth, depth)
+      prop.value.properties = await getObjectProperties(subtype, objectId, opts, depth)
     } else if (type === 'function') {
-      prop.value.properties = await getFunctionProperties(objectId, maxDepth, depth + 1)
+      prop.value.properties = await getFunctionProperties(objectId, opts, depth + 1)
     }
   }
 
   return props
 }
 
-async function getObjectProperties (subtype, objectId, maxDepth, depth) {
+async function getObjectProperties (subtype, objectId, opts, depth) {
   if (ITERABLE_SUBTYPES.has(subtype)) {
-    return getIterable(objectId, maxDepth, depth)
+    return getIterable(objectId, opts, depth)
   } else if (subtype === 'promise') {
-    return getInternalProperties(objectId, maxDepth, depth)
+    return getInternalProperties(objectId, opts, depth)
   } else if (subtype === 'proxy') {
-    return getProxy(objectId, maxDepth, depth)
+    return getProxy(objectId, opts, depth)
   } else if (subtype === 'arraybuffer') {
-    return getArrayBuffer(objectId, maxDepth, depth)
+    return getArrayBuffer(objectId, opts, depth)
   } else {
-    return getObject(objectId, maxDepth, depth + 1)
+    return getObject(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
   }
 }
 
 // TODO: The following extra information from `internalProperties` might be relevant to include for functions:
 // - Bound function: `[[TargetFunction]]`, `[[BoundThis]]` and `[[BoundArgs]]`
 // - Non-bound function: `[[FunctionLocation]]`, and `[[Scopes]]`
-async function getFunctionProperties (objectId, maxDepth, depth) {
+async function getFunctionProperties (objectId, opts, depth) {
   let { result } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -72,10 +89,12 @@ async function getFunctionProperties (objectId, maxDepth, depth) {
   // For legacy reasons (I assume) functions has a `prototype` property besides the internal `[[Prototype]]`
   result = result.filter(({ name }) => name !== 'prototype')
 
-  return traverseGetPropertiesResult(result, maxDepth, depth)
+  return traverseGetPropertiesResult(result, opts, depth)
 }
 
-async function getIterable (objectId, maxDepth, depth) {
+async function getIterable (objectId, opts, depth) {
+  // TODO: If the iterable has any properties defined on the object directly, instead of in its collection, they will
+  // exist in the return value below in the `result` property. We currently do not collect these.
   const { internalProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -93,10 +112,17 @@ async function getIterable (objectId, maxDepth, depth) {
     ownProperties: true // exclude inherited properties
   })
 
-  return traverseGetPropertiesResult(result, maxDepth, depth)
+  removeNonEnumerableProperties(result) // remove the `length` property
+  const size = result.length
+  if (size > opts.maxCollectionSize) {
+    result.splice(opts.maxCollectionSize)
+    result[collectionSizeSym] = size
+  }
+
+  return traverseGetPropertiesResult(result, opts, depth)
 }
 
-async function getInternalProperties (objectId, maxDepth, depth) {
+async function getInternalProperties (objectId, opts, depth) {
   const { internalProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -105,10 +131,10 @@ async function getInternalProperties (objectId, maxDepth, depth) {
   // We want all internal properties except the prototype
   const props = internalProperties.filter(({ name }) => name !== '[[Prototype]]')
 
-  return traverseGetPropertiesResult(props, maxDepth, depth)
+  return traverseGetPropertiesResult(props, opts, depth)
 }
 
-async function getProxy (objectId, maxDepth, depth) {
+async function getProxy (objectId, opts, depth) {
   const { internalProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -127,14 +153,14 @@ async function getProxy (objectId, maxDepth, depth) {
     ownProperties: true // exclude inherited properties
   })
 
-  return traverseGetPropertiesResult(result, maxDepth, depth)
+  return traverseGetPropertiesResult(result, opts, depth)
 }
 
 // Support for ArrayBuffer is a bit trickly because the internal structure stored in `internalProperties` is not
 // documented and is not straight forward. E.g. ArrayBuffer(3) will internally contain both Int8Array(3) and
 // UInt8Array(3), whereas ArrayBuffer(8) internally contains both Int8Array(8), Uint8Array(8), Int16Array(4), and
 // Int32Array(2) - all representing the same data in different ways.
-async function getArrayBuffer (objectId, maxDepth, depth) {
+async function getArrayBuffer (objectId, opts, depth) {
   const { internalProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -149,5 +175,13 @@ async function getArrayBuffer (objectId, maxDepth, depth) {
     ownProperties: true // exclude inherited properties
   })
 
-  return traverseGetPropertiesResult(result, maxDepth, depth)
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+function removeNonEnumerableProperties (props) {
+  for (let i = 0; i < props.length; i++) {
+    if (props[i].enumerable === false) {
+      props.splice(i--, 1)
+    }
+  }
 }

package/packages/dd-trace/src/debugger/devtools_client/snapshot/index.js

@@ -4,6 +4,8 @@ const { getRuntimeObject } = require('./collector')
 const { processRawState } = require('./processor')
 
 const DEFAULT_MAX_REFERENCE_DEPTH = 3
+const DEFAULT_MAX_COLLECTION_SIZE = 100
+const DEFAULT_MAX_FIELD_COUNT = 20
 const DEFAULT_MAX_LENGTH = 255
 
 module.exports = {
@@ -12,14 +14,22 @@ module.exports = {
 
 async function getLocalStateForCallFrame (
   callFrame,
-  { maxReferenceDepth = DEFAULT_MAX_REFERENCE_DEPTH, maxLength = DEFAULT_MAX_LENGTH } = {}
+  {
+    maxReferenceDepth = DEFAULT_MAX_REFERENCE_DEPTH,
+    maxCollectionSize = DEFAULT_MAX_COLLECTION_SIZE,
+    maxFieldCount = DEFAULT_MAX_FIELD_COUNT,
+    maxLength = DEFAULT_MAX_LENGTH
+  } = {}
 ) {
   const rawState = []
   let processedState = null
 
   for (const scope of callFrame.scopeChain) {
     if (scope.type === 'global') continue // The global scope is too noisy
-    rawState.push(...await getRuntimeObject(scope.object.objectId, maxReferenceDepth))
+    rawState.push(...await getRuntimeObject(
+      scope.object.objectId,
+      { maxReferenceDepth, maxCollectionSize, maxFieldCount }
+    ))
   }
 
   // Deplay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`

package/packages/dd-trace/src/debugger/devtools_client/snapshot/processor.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { collectionSizeSym, fieldCountSym } = require('./symbols')
+
 module.exports = {
   processRawState: processProperties
 }
@@ -137,38 +139,46 @@ function toString (str, maxLength) {
 
 function toObject (type, props, maxLength) {
   if (props === undefined) return notCapturedDepth(type)
-  return { type, fields: processProperties(props, maxLength) }
+
+  const result = {
+    type,
+    fields: processProperties(props, maxLength)
+  }
+
+  if (fieldCountSym in props) {
+    result.notCapturedReason = 'fieldCount'
+    result.size = props[fieldCountSym]
+  }
+
+  return result
 }
 
 function toArray (type, elements, maxLength) {
   if (elements === undefined) return notCapturedDepth(type)
 
   // Perf: Create array of expected size in advance (expect that it contains only one non-enumrable element)
-  const expectedLength = elements.length - 1
-  const result = { type, elements: new Array(expectedLength) }
+  const result = { type, elements: new Array(elements.length) }
+
+  setNotCaptureReasonOnCollection(result, elements)
 
   let i = 0
   for (const elm of elements) {
-    if (elm.enumerable === false) continue // the value of the `length` property should not be part of the array
     result.elements[i++] = getPropertyValue(elm, maxLength)
   }
 
-  // Safe-guard in case there were more than one non-enumerable element
-  if (i < expectedLength) result.elements.length = i
-
   return result
 }
 
 function toMap (type, pairs, maxLength) {
   if (pairs === undefined) return notCapturedDepth(type)
 
-  // Perf: Create array of expected size in advance (expect that it contains only one non-enumrable element)
-  const expectedLength = pairs.length - 1
-  const result = { type, entries: new Array(expectedLength) }
+  // Perf: Create array of expected size in advance
+  const result = { type, entries: new Array(pairs.length) }
+
+  setNotCaptureReasonOnCollection(result, pairs)
 
   let i = 0
   for (const pair of pairs) {
-    if (pair.enumerable === false) continue // the value of the `length` property should not be part of the map
     // The following code is based on assumptions made when researching the output of the Chrome DevTools Protocol.
     // There doesn't seem to be any documentation to back it up:
     //
@@ -180,9 +190,6 @@ function toMap (type, pairs, maxLength) {
     result.entries[i++] = [key, val]
   }
 
-  // Safe-guard in case there were more than one non-enumerable element
-  if (i < expectedLength) result.entries.length = i
-
   return result
 }
 
@@ -190,12 +197,12 @@ function toSet (type, values, maxLength) {
   if (values === undefined) return notCapturedDepth(type)
 
   // Perf: Create array of expected size in advance (expect that it contains only one non-enumrable element)
-  const expectedLength = values.length - 1
-  const result = { type, elements: new Array(expectedLength) }
+  const result = { type, elements: new Array(values.length) }
+
+  setNotCaptureReasonOnCollection(result, values)
 
   let i = 0
   for (const value of values) {
-    if (value.enumerable === false) continue // the value of the `length` property should not be part of the set
     // The following code is based on assumptions made when researching the output of the Chrome DevTools Protocol.
     // There doesn't seem to be any documentation to back it up:
     //
@@ -205,9 +212,6 @@ function toSet (type, values, maxLength) {
     result.elements[i++] = getPropertyValue(value.value.properties[0], maxLength)
   }
 
-  // Safe-guard in case there were more than one non-enumerable element
-  if (i < expectedLength) result.elements.length = i
-
   return result
 }
 
@@ -236,6 +240,13 @@ function arrayBufferToString (bytes, size) {
   return buf.toString()
 }
 
+function setNotCaptureReasonOnCollection (result, collection) {
+  if (collectionSizeSym in collection) {
+    result.notCapturedReason = 'collectionSize'
+    result.size = collection[collectionSizeSym]
+  }
+}
+
 function notCapturedDepth (type) {
   return { type, notCapturedReason: 'depth' }
 }

package/packages/dd-trace/src/debugger/devtools_client/snapshot/symbols.js

@@ -0,0 +1,6 @@
+'use stict'
+
+module.exports = {
+  collectionSizeSym: Symbol('datadog.collectionSize'),
+  fieldCountSym: Symbol('datadog.fieldCount')
+}

package/packages/dd-trace/src/debugger/devtools_client/state.js

@@ -32,8 +32,17 @@ module.exports = {
       .sort(([a], [b]) => a.length - b.length)[0]
   },
 
-  getScriptUrlFromId (id) {
-    return scriptUrls.get(id)
+  getStackFromCallFrames (callFrames) {
+    return callFrames.map((frame) => {
+      let fileName = scriptUrls.get(frame.location.scriptId)
+      if (fileName.startsWith('file://')) fileName = fileName.substr(7) // TODO: This might not be required
+      return {
+        fileName,
+        function: frame.functionName,
+        lineNumber: frame.location.lineNumber + 1, // Beware! lineNumber is zero-indexed
+        columnNumber: frame.location.columnNumber + 1 // Beware! columnNumber is zero-indexed
+      }
+    })
   }
 }
 

package/packages/dd-trace/src/debugger/index.js

@@ -6,6 +6,7 @@ const log = require('../log')
 
 let worker = null
 let configChannel = null
+let ackId = 0
 
 const { NODE_OPTIONS, ...env } = process.env
 
@@ -24,13 +25,19 @@ function start (config, rc) {
   configChannel = new MessageChannel()
 
   rc.setProductHandler('LIVE_DEBUGGING', (action, conf, id, ack) => {
-    const ackId = `${id}-${conf.version}`
-    rcAckCallbacks.set(ackId, ack)
+    rcAckCallbacks.set(++ackId, ack)
     rcChannel.port2.postMessage({ action, conf, ackId })
   })
 
   rcChannel.port2.on('message', ({ ackId, error }) => {
-    rcAckCallbacks.get(ackId)(error)
+    const ack = rcAckCallbacks.get(ackId)
+    if (ack === undefined) {
+      // This should never happen, but just in case something changes in the future, we should guard against it
+      log.error(`Received an unknown ackId: ${ackId}`)
+      if (error) log.error(error)
+      return
+    }
+    ack(error)
     rcAckCallbacks.delete(ackId)
   })
   rcChannel.port2.on('messageerror', (err) => log.error(err))

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -0,0 +1,34 @@
+'use strict'
+
+module.exports = {
+  SPAN_KINDS: ['llm', 'agent', 'workflow', 'task', 'tool', 'embedding', 'retrieval'],
+  SPAN_KIND: '_ml_obs.meta.span.kind',
+  SESSION_ID: '_ml_obs.session_id',
+  METADATA: '_ml_obs.meta.metadata',
+  METRICS: '_ml_obs.metrics',
+  ML_APP: '_ml_obs.meta.ml_app',
+  PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
+  PARENT_ID_KEY: '_ml_obs.llmobs_parent_id',
+  TAGS: '_ml_obs.tags',
+  NAME: '_ml_obs.name',
+  TRACE_ID: '_ml_obs.trace_id',
+  PROPAGATED_TRACE_ID_KEY: '_dd.p.llmobs_trace_id',
+  ROOT_PARENT_ID: 'undefined',
+
+  MODEL_NAME: '_ml_obs.meta.model_name',
+  MODEL_PROVIDER: '_ml_obs.meta.model_provider',
+
+  INPUT_DOCUMENTS: '_ml_obs.meta.input.documents',
+  INPUT_MESSAGES: '_ml_obs.meta.input.messages',
+  INPUT_VALUE: '_ml_obs.meta.input.value',
+
+  OUTPUT_DOCUMENTS: '_ml_obs.meta.output.documents',
+  OUTPUT_MESSAGES: '_ml_obs.meta.output.messages',
+  OUTPUT_VALUE: '_ml_obs.meta.output.value',
+
+  INPUT_TOKENS_METRIC_KEY: 'input_tokens',
+  OUTPUT_TOKENS_METRIC_KEY: 'output_tokens',
+  TOTAL_TOKENS_METRIC_KEY: 'total_tokens',
+
+  DROPPED_IO_COLLECTION_ERROR: 'dropped_io'
+}

package/packages/dd-trace/src/llmobs/constants/text.js

@@ -0,0 +1,6 @@
+'use strict'
+
+module.exports = {
+  DROPPED_VALUE_TEXT: "[This value has been dropped because this span's size exceeds the 1MB size limit.]",
+  UNSERIALIZABLE_VALUE_TEXT: 'Unserializable value'
+}

package/packages/dd-trace/src/llmobs/constants/writers.js

@@ -0,0 +1,13 @@
+'use strict'
+
+module.exports = {
+  EVP_PROXY_AGENT_BASE_PATH: 'evp_proxy/v2',
+  EVP_PROXY_AGENT_ENDPOINT: 'evp_proxy/v2/api/v2/llmobs',
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+  EVP_SUBDOMAIN_HEADER_VALUE: 'llmobs-intake',
+  AGENTLESS_SPANS_ENDPOINT: '/api/v2/llmobs',
+  AGENTLESS_EVALULATIONS_ENDPOINT: '/api/intake/llm-obs/v1/eval-metric',
+
+  EVP_PAYLOAD_SIZE_LIMIT: 5 << 20, // 5MB (actual limit is 5.1MB)
+  EVP_EVENT_SIZE_LIMIT: (1 << 20) - 1024 // 999KB (actual limit is 1MB)
+}

package/packages/dd-trace/src/llmobs/index.js

@@ -0,0 +1,103 @@
+'use strict'
+
+const log = require('../log')
+const { PROPAGATED_PARENT_ID_KEY } = require('./constants/tags')
+const { storage } = require('./storage')
+
+const LLMObsSpanProcessor = require('./span_processor')
+
+const { channel } = require('dc-polyfill')
+const spanProcessCh = channel('dd-trace:span:process')
+const evalMetricAppendCh = channel('llmobs:eval-metric:append')
+const flushCh = channel('llmobs:writers:flush')
+const injectCh = channel('dd-trace:span:inject')
+
+const LLMObsAgentlessSpanWriter = require('./writers/spans/agentless')
+const LLMObsAgentProxySpanWriter = require('./writers/spans/agentProxy')
+const LLMObsEvalMetricsWriter = require('./writers/evaluations')
+
+/**
+ * Setting writers and processor globally when LLMObs is enabled
+ * We're setting these in this module instead of on the SDK.
+ * This is to isolate any subscribers and periodic tasks to this module,
+ * and not conditionally instantiate in the SDK, since the SDK is always instantiated
+ * if the tracer is `init`ed. But, in those cases, we don't want to start writers or subscribe
+ * to channels.
+ */
+let spanProcessor
+let spanWriter
+let evalWriter
+
+function enable (config) {
+  // create writers and eval writer append and flush channels
+  // span writer append is handled by the span processor
+  evalWriter = new LLMObsEvalMetricsWriter(config)
+  spanWriter = createSpanWriter(config)
+
+  evalMetricAppendCh.subscribe(handleEvalMetricAppend)
+  flushCh.subscribe(handleFlush)
+
+  // span processing
+  spanProcessor = new LLMObsSpanProcessor(config)
+  spanProcessor.setWriter(spanWriter)
+  spanProcessCh.subscribe(handleSpanProcess)
+
+  // distributed tracing for llmobs
+  injectCh.subscribe(handleLLMObsParentIdInjection)
+}
+
+function disable () {
+  if (evalMetricAppendCh.hasSubscribers) evalMetricAppendCh.unsubscribe(handleEvalMetricAppend)
+  if (flushCh.hasSubscribers) flushCh.unsubscribe(handleFlush)
+  if (spanProcessCh.hasSubscribers) spanProcessCh.unsubscribe(handleSpanProcess)
+  if (injectCh.hasSubscribers) injectCh.unsubscribe(handleLLMObsParentIdInjection)
+
+  spanWriter?.destroy()
+  evalWriter?.destroy()
+  spanProcessor?.setWriter(null)
+
+  spanWriter = null
+  evalWriter = null
+}
+
+// since LLMObs traces can extend between services and be the same trace,
+// we need to propogate the parent id.
+function handleLLMObsParentIdInjection ({ carrier }) {
+  const parent = storage.getStore()?.span
+  if (!parent) return
+
+  const parentId = parent?.context().toSpanId()
+
+  carrier['x-datadog-tags'] += `,${PROPAGATED_PARENT_ID_KEY}=${parentId}`
+}
+
+function createSpanWriter (config) {
+  const SpanWriter = config.llmobs.agentlessEnabled ? LLMObsAgentlessSpanWriter : LLMObsAgentProxySpanWriter
+  return new SpanWriter(config)
+}
+
+function handleFlush () {
+  try {
+    spanWriter.flush()
+    evalWriter.flush()
+  } catch (e) {
+    log.warn(`Failed to flush LLMObs spans and evaluation metrics: ${e.message}`)
+  }
+}
+
+function handleSpanProcess (data) {
+  spanProcessor.process(data)
+}
+
+function handleEvalMetricAppend (payload) {
+  try {
+    evalWriter.append(payload)
+  } catch (e) {
+    log.warn(`
+      Failed to append evaluation metric to LLM Observability writer, likely due to an unserializable property.
+      Evaluation metrics won't be sent to LLM Observability: ${e.message}
+    `)
+  }
+}
+
+module.exports = { enable, disable }

package/packages/dd-trace/src/llmobs/noop.js

@@ -0,0 +1,82 @@
+'use strict'
+
+class NoopLLMObs {
+  constructor (noopTracer) {
+    this._tracer = noopTracer
+  }
+
+  get enabled () {
+    return false
+  }
+
+  enable (options) {}
+
+  disable () {}
+
+  trace (options = {}, fn) {
+    if (typeof options === 'function') {
+      fn = options
+      options = {}
+    }
+
+    const name = options.name || options.kind || fn.name
+
+    return this._tracer.trace(name, options, fn)
+  }
+
+  wrap (options = {}, fn) {
+    if (typeof options === 'function') {
+      fn = options
+      options = {}
+    }
+
+    const name = options.name || options.kind || fn.name
+
+    return this._tracer.wrap(name, options, fn)
+  }
+
+  decorate (options = {}) {
+    const llmobs = this
+    return function (target, ctxOrPropertyKey, descriptor) {
+      if (!ctxOrPropertyKey) return target
+      if (typeof ctxOrPropertyKey === 'object') {
+        const ctx = ctxOrPropertyKey
+        if (ctx.kind !== 'method') return target
+
+        return llmobs.wrap({ name: ctx.name, ...options }, target)
+      } else {
+        const propertyKey = ctxOrPropertyKey
+        if (descriptor) {
+          if (typeof descriptor.value !== 'function') return descriptor
+
+          const original = descriptor.value
+          descriptor.value = llmobs.wrap({ name: propertyKey, ...options }, original)
+
+          return descriptor
+        } else {
+          if (typeof target[propertyKey] !== 'function') return target[propertyKey]
+
+          const original = target[propertyKey]
+          Object.defineProperty(target, propertyKey, {
+            ...Object.getOwnPropertyDescriptor(target, propertyKey),
+            value: llmobs.wrap({ name: propertyKey, ...options }, original)
+          })
+
+          return target
+        }
+      }
+    }
+  }
+
+  annotate (span, options) {}
+
+  exportSpan (span) {
+    return {}
+  }
+
+  submitEvaluation (llmobsSpanContext, options) {}
+
+  flush () {}
+}
+
+module.exports = NoopLLMObs