dd-trace 6.7.0 → 6.9.0

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

@@ -3,7 +3,6 @@
 const { channel } = require('dc-polyfill')
 
 const { isError } = require('../util')
-const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
 const Span = require('../opentracing/span')
@@ -13,6 +12,17 @@ const {
   INPUT_VALUE,
   TRACE_ID,
 } = require('./constants/tags')
+const {
+  FEEDBACK_METRIC_TYPES,
+  FEEDBACK_TARGET_KEYS,
+  buildMetricTags,
+  validateAssessment,
+  validateLabel,
+  validateMetricType,
+  validateMetricValue,
+  validateReasoning,
+  validateTimestamp,
+} = require('./eval-metric')
 const {
   getFunctionArguments,
   validateKind,
@@ -35,12 +45,6 @@ class LLMObs extends NoopLLMObs {
    */
   #hasUserSpanProcessor = false
 
-  /**
-   * Lazily-created experiments facade (see ./experiments).
-   * @type {import('./experiments').Experiments | undefined}
-   */
-  #experiments
-
   /**
    * @param {import('../tracer')} tracer - Tracer instance
    * @param {import('./index')} llmobsModule - LLMObs module instance
@@ -66,8 +70,7 @@ class LLMObs extends NoopLLMObs {
    * a clear message on use.
    */
   get experiments () {
-    this.#experiments ??= createExperiments(this._config)
-    return this.#experiments
+    return createExperiments(this._config, this)
   }
 
   enable (options = {}) {
@@ -318,14 +321,14 @@ class LLMObs extends NoopLLMObs {
       }
       throw e
     } finally {
-      if (autoinstrumented === false) {
+      if (!autoinstrumented) {
         telemetry.recordLLMObsAnnotate(span, err)
       }
     }
   }
 
   exportSpan (span) {
-    span = span || this._active()
+    span ||= this._active()
     let err = ''
     try {
       if (!span) {
@@ -399,92 +402,35 @@ class LLMObs extends NoopLLMObs {
       }
 
       const timestampMs = options.timestampMs || Date.now()
-      if (typeof timestampMs !== 'number' || timestampMs < 0) {
-        err = 'invalid_timestamp'
-        throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
-      }
+      validateTimestamp(timestampMs, 'evaluation')
 
       const { label, value, tags, reasoning, assessment, metadata } = options
       const metricType = options.metricType?.toLowerCase()
-      if (!label) {
-        err = 'invalid_metric_label'
-        throw new Error('label must be the specified name of the evaluation metric')
-      }
-      if (!metricType || !['categorical', 'score', 'boolean', 'json'].includes(metricType)) {
-        err = 'invalid_metric_type'
-        throw new Error('metricType must be one of "categorical", "score", "boolean" or "json"')
-      }
-      if (metricType === 'categorical' && typeof value !== 'string') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a string for a categorical metric.')
-      }
-      if (metricType === 'score' && typeof value !== 'number') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a number for a score metric.')
-      }
-      if (metricType === 'boolean' && typeof value !== 'boolean') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a boolean for a boolean metric')
-      }
-      if (metricType === 'json' && !(typeof value === 'object' && value != null && !Array.isArray(value))) {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a JSON object for a json metric')
-      }
-      if (assessment != null && assessment !== 'pass' && assessment !== 'fail') {
-        err = 'invalid_assessment'
-        throw new Error('assessment must be pass or fail')
-      }
-      if (reasoning != null && typeof reasoning !== 'string') {
-        err = 'invalid_reasoning'
-        throw new Error('reasoning must be a string')
-      }
+      const labelValue = validateLabel(label, 'evaluation')
+      validateMetricType(metricType, 'evaluation')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
       if (metadata != null && (typeof metadata !== 'object' || Array.isArray(metadata))) {
         err = 'invalid_metadata'
         throw new Error('metadata must be a JSON object')
       }
 
-      const evaluationTags = {
-        'ddtrace.version': tracerVersion,
-        ml_app: mlApp,
-      }
-
-      if (tags) {
-        for (const key in tags) {
-          const tag = tags[key]
-          if (typeof tag === 'string') {
-            evaluationTags[key] = tag
-          } else if (typeof tag.toString === 'function') {
-            evaluationTags[key] = tag.toString()
-          } else if (tag == null) {
-            evaluationTags[key] = Object.prototype.toString.call(tag)
-          } else {
-            // should be a rare case
-            // every object in JS has a toString, otherwise every primitive has its own toString
-            // null and undefined are handled above
-            err = 'invalid_tags'
-            throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
-          }
-        }
-      }
-
-      // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
-      if (this._config.DD_TRACE_OTEL_ENABLED) {
-        evaluationTags.source = 'otel'
-      }
-
       const payload = {
+        event_kind: 'evaluation',
         join_on: {
           span: {
             span_id: spanId,
             trace_id: traceId,
           },
         },
-        label,
+        label: labelValue,
         metric_type: metricType,
         ml_app: mlApp,
         [`${metricType}_value`]: value,
         timestamp_ms: timestampMs,
-        tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`),
+        // When OTel tracing is enabled, `source:otel` lets the backend wait for OTel span conversion
+        tags: buildMetricTags(tags, mlApp, 'evaluation', this._config.DD_TRACE_OTEL_ENABLED),
       }
       if (reasoning != null) {
         payload.reasoning = reasoning
@@ -498,11 +444,139 @@ class LLMObs extends NoopLLMObs {
       const currentStore = storage.getStore()
       const routing = currentStore?.routingContext
       evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
     } finally {
       telemetry.recordSubmitEvaluation(options, err)
     }
   }
 
+  /**
+   * Submits end-user feedback for a span, trace, session, or customer-defined entity.
+   *
+   * Exactly one target must be provided: `span` (as returned by `llmobs.exportSpan()`) or
+   * `spanId` to target a span, `traceId` a trace, `sessionId` a session, or `feedbackJoinKey`
+   * a customer-defined entity.
+   * `label`, `metricType`, `value` and `submitter` are required, and are validated at call time.
+   * @param {object} [options] - The feedback options.
+   * @param {string} [options.label] - The name of the feedback metric.
+   * @param {'categorical' | 'score' | 'boolean' | 'json' | 'text'} [options.metricType] - The value type.
+   * @param {string | number | boolean | Record<string, unknown>} [options.value] - The feedback value,
+   *   matching `metricType`.
+   * @param {{ id: string, type?: string }} [options.submitter] - Who submitted the feedback.
+   * @param {{ traceId: string, spanId: string }} [options.span] - Span context to attach the feedback to.
+   * @param {string} [options.spanId] - ID of the span to attach the feedback to.
+   * @param {string} [options.traceId] - ID of the trace to attach the feedback to.
+   * @param {string} [options.sessionId] - ID of the session to attach the feedback to.
+   * @param {string} [options.feedbackJoinKey] - Customer-defined key to attach the feedback to.
+   * @param {Record<string, string>} [options.tags] - Tags to attach to the feedback.
+   * @param {string} [options.mlApp] - The ML app name. Defaults to the configured one.
+   * @param {number} [options.timestampMs] - When the feedback was generated. Defaults to now.
+   * @param {'pass' | 'fail'} [options.assessment] - Assessment of the feedback.
+   * @param {string} [options.reasoning] - Explanation of the feedback.
+   * @returns {void}
+   */
+  submitFeedback (options = {}) {
+    if (!this.enabled) return
+
+    let err = ''
+    let targetType = 'other'
+    let metricTypeTag = 'other'
+    try {
+      const { span, spanId, traceId, sessionId, feedbackJoinKey, submitter } = options
+
+      // Resolved before any validation so telemetry still reports the metric type of a
+      // submission that fails on an unrelated field.
+      const metricType = options.metricType?.toLowerCase()
+      if (FEEDBACK_METRIC_TYPES.includes(metricType)) metricTypeTag = metricType
+
+      // The intake keys feedback off a single top-level identifier, so more than one target
+      // would be ambiguous and none would leave the feedback unattached. `span` also carries a
+      // traceId, but passing it is wire-equivalent to passing its `spanId` directly.
+      let targetName, targetValue
+      let targetCount = 0
+      if (span != null) { targetName = 'span'; targetValue = span.spanId; targetCount++ }
+      if (spanId != null) { targetName = 'spanId'; targetValue = spanId; targetCount++ }
+      if (traceId != null) { targetName = 'traceId'; targetValue = traceId; targetCount++ }
+      if (sessionId != null) { targetName = 'sessionId'; targetValue = sessionId; targetCount++ }
+      if (feedbackJoinKey != null) { targetName = 'feedbackJoinKey'; targetValue = feedbackJoinKey; targetCount++ }
+
+      if (targetCount !== 1) {
+        err = 'invalid_target_count'
+        throw new Error(
+          'Exactly one of `span`, `spanId`, `traceId`, `sessionId` or `feedbackJoinKey` ' +
+          'must be specified to submit feedback.'
+        )
+      }
+
+      targetType = FEEDBACK_TARGET_KEYS[targetName]
+      if (typeof targetValue !== 'string' || !targetValue) {
+        if (targetName === 'span') {
+          err = 'invalid_span'
+          throw new TypeError(
+            '`span` must be an object containing a non-empty string spanId. ' +
+            '`llmobs.exportSpan()` can be used to generate this object from a given span.'
+          )
+        }
+        err = `invalid_${targetType}`
+        throw new TypeError(`\`${targetName}\` must be a non-empty string`)
+      }
+
+      if (typeof submitter?.id !== 'string' || !submitter.id) {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter must be an object containing a non-empty string id')
+      }
+      if (submitter.type != null && typeof submitter.type !== 'string') {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter.type must be a string')
+      }
+
+      const mlApp = options.mlApp || this._config.llmobs.mlApp
+      if (!mlApp) {
+        err = 'missing_ml_app'
+        throw new Error('ML App name is required for sending feedback. Feedback data will not be sent.')
+      }
+
+      const timestampMs = options.timestampMs || Date.now()
+      validateTimestamp(timestampMs, 'feedback')
+
+      const { label, value, tags, reasoning, assessment } = options
+      const labelValue = validateLabel(label, 'feedback')
+      validateMetricType(metricType, 'feedback')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
+
+      const payload = {
+        event_kind: 'feedback',
+        [targetType]: targetValue,
+        label: labelValue,
+        metric_type: metricType,
+        ml_app: mlApp,
+        [`${metricType}_value`]: value,
+        timestamp_ms: timestampMs,
+        tags: buildMetricTags(tags, mlApp, 'feedback'),
+        submitter: submitter.type == null ? { id: submitter.id } : { id: submitter.id, type: submitter.type },
+      }
+      if (reasoning != null) {
+        payload.reasoning = reasoning
+      }
+      if (assessment != null) {
+        payload.assessment = assessment
+      }
+
+      const currentStore = storage.getStore()
+      const routing = currentStore?.routingContext
+      evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
+    } finally {
+      telemetry.recordSubmitFeedback(metricTypeTag, targetType, err)
+    }
+  }
+
   annotationContext (options, fn) {
     if (!this.enabled) return fn()
 

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

@@ -239,6 +239,14 @@ class LLMObsSpanProcessor {
 
     const apmTraceId = span.context().toTraceId(true)
     const llmobsTraceId = mlObsTags[TRACE_ID] ?? apmTraceId
+    const dd = {
+      span_id: span.context().toSpanId(),
+      trace_id: apmTraceId,
+      sample_rate: mlObsTags[SAMPLE_RATE],
+      sampling_decision: mlObsTags[SAMPLING_DECISION],
+      apm_trace_id: apmTraceId,
+    }
+    if (tags.experiment_id) dd.scope = 'experiments'
 
     const llmObsSpanEvent = {
       trace_id: llmobsTraceId,
@@ -251,13 +259,7 @@ class LLMObsSpanProcessor {
       status: error ? 'error' : 'ok',
       meta,
       metrics,
-      _dd: {
-        span_id: span.context().toSpanId(),
-        trace_id: apmTraceId,
-        sample_rate: mlObsTags[SAMPLE_RATE],
-        sampling_decision: mlObsTags[SAMPLING_DECISION],
-        apm_trace_id: apmTraceId,
-      },
+      _dd: dd,
     }
 
     if (sessionId) llmObsSpanEvent.session_id = sessionId

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

@@ -158,8 +158,7 @@ class LLMObsTagger {
     if (modelName) this.tagModelName(span, modelName)
     if (modelProvider) this._setTag(span, MODEL_PROVIDER, modelProvider)
 
-    sessionId = sessionId ||
-      registry.get(parent)?.[SESSION_ID] ||
+    sessionId ||= registry.get(parent)?.[SESSION_ID] ||
       traceTags[SESSION_ID_TRACE_DEFAULT_KEY] ||
       traceTags[PROPAGATED_SESSION_ID_KEY]
     if (sessionId) this._setTag(span, SESSION_ID, sessionId)

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

@@ -183,6 +183,23 @@ function recordSubmitEvaluation (options, err, value = 1) {
   llmobsMetrics.count('evals_submitted', tags).inc(value)
 }
 
+/**
+ * @param {string} metricType - The submitted metric type, `'other'` if unrecognized.
+ * @param {string} targetType - The payload key the feedback was attached to, `'other'` if unresolved.
+ * @param {string} err - The telemetry error tag, empty when the submission succeeded.
+ * @param {number} [value]
+ * @returns {void}
+ */
+function recordSubmitFeedback (metricType, targetType, err, value = 1) {
+  const tags = {
+    error: Number(!!err),
+    metric_type: metricType,
+    target_type: targetType,
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('feedback_submitted', tags).inc(value)
+}
+
 function recordLLMObsUserProcessorCalled (error, value = 1) {
   const tags = { error: error ? 1 : 0 }
   llmobsMetrics.count('user_processor_called', tags).inc(value)
@@ -201,5 +218,6 @@ module.exports = {
   recordUserFlush,
   recordExportSpan,
   recordSubmitEvaluation,
+  recordSubmitFeedback,
   recordLLMObsUserProcessorCalled,
 }

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

@@ -88,6 +88,9 @@ class BaseLLMObsWriter {
   }
 
   /**
+   * @param {Record<string, unknown>} event
+   * @param {{ apiKey?: string, site?: string }} [routing]
+   * @param {number} [byteLength]
    * @returns {boolean} `true` if the event was buffered, `false` if it was dropped
    * (e.g. the per-routing buffer was full). Callers that depend on the event
    * actually being submitted should check this value.

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

@@ -49,12 +49,18 @@ class LLMObsSpanWriter extends BaseWriter {
   }
 
   makePayload (events) {
-    return events.map(event => ({
-      '_dd.stage': 'raw',
-      '_dd.tracer_version': tracerVersion,
-      event_type: this._eventType,
-      spans: [event],
-    }))
+    return events.map(event => {
+      const eventData = {
+        '_dd.stage': 'raw',
+        '_dd.tracer_version': tracerVersion,
+        event_type: this._eventType,
+        spans: [event],
+      }
+      if (event?._dd?.scope === 'experiments') {
+        eventData['_dd.scope'] = 'experiments'
+      }
+      return eventData
+    })
   }
 
   _truncateSpanEvent (event) {

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

@@ -7,6 +7,8 @@ const { fetchAgentInfo } = require('../../agent/info')
 
 /**
  * @param {import('../../config/config-base')} config
+ * @param {(agentless: boolean) => void} setWritersAgentlessValue
+ * @returns {void}
  */
 function setAgentStrategy (config, setWritersAgentlessValue) {
   const agentlessEnabled = config.llmobs.agentlessEnabled

package/packages/dd-trace/src/log/channels.js

@@ -2,15 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const Level = {
-  trace: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  critical: 50,
-  off: 100,
-}
+const Level = require('./levels')
 
 const traceChannel = channel('datadog:log:trace')
 const debugChannel = channel('datadog:log:debug')

package/packages/dd-trace/src/log/levels.js

@@ -0,0 +1,12 @@
+'use strict'
+
+// The guardrails logger requires this file, so it has to parse on Node.js 0.8.
+module.exports = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
+}

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

@@ -55,7 +55,7 @@ class NoopProxy {
 
     if (typeof fn !== 'function') return
 
-    options = options || {}
+    options ||= {}
 
     return this._tracer.trace(name, options, fn)
   }
@@ -68,7 +68,7 @@ class NoopProxy {
 
     if (typeof fn !== 'function') return fn
 
-    options = options || {}
+    options ||= {}
 
     return this._tracer.wrap(name, options, fn)
   }

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -63,7 +63,7 @@ class ExposuresWriter extends BaseFFEWriter {
    * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
-    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
     const fullEndpoint = `${basePath}/${endpoint}`
 

package/packages/dd-trace/src/openfeature/writers/util.js

@@ -18,7 +18,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
     }
 
     const endpoints = agentInfo.endpoints
-    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const hasEndpoint = Array.isArray(endpoints) &&
       endpoints.includes(normalizedPath) || endpoints.includes(normalizedPath + '/')
 

package/packages/dd-trace/src/opentelemetry/logs/batch_log_processor.js

@@ -22,7 +22,7 @@ class BatchLogRecordProcessor {
   /**
    * Creates a new BatchLogRecordProcessor instance.
    *
-   * @param {OtlpHttpLogExporter} exporter - Log processor for exporting batches to Datadog Agent
+   * @param {import('./otlp_http_log_exporter')} exporter - Log processor for exporting batches to Datadog Agent
    * @param {number} batchTimeout - Timeout in milliseconds for batch processing
    * @param {number} maxExportBatchSize - Maximum number of log records per batch
    */

package/packages/dd-trace/src/opentelemetry/metrics/meter.js

@@ -9,6 +9,8 @@ const { METRIC_TYPES } = require('./constants')
 /**
  * @typedef {import('@opentelemetry/api').MetricOptions} MetricOptions
  * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ * @typedef {Counter | UpDownCounter | Histogram | Gauge |
+ *   ObservableGauge | ObservableCounter | ObservableUpDownCounter} Instrument
  */
 
 /**
@@ -25,7 +27,7 @@ class Meter {
   /**
    * Creates a new Meter instance.
    *
-   * @param {MeterProvider} meterProvider - Parent meter provider
+   * @param {import('./meter_provider')} meterProvider - Parent meter provider
    * @param {InstrumentationScope} instrumentationScope - Instrumentation scope information
    * @param {string} [instrumentationScope.name] - Meter name (defaults to 'dd-trace-js')
    * @param {string} [instrumentationScope.version] - Meter version (defaults to tracer version)
@@ -50,11 +52,13 @@ class Meter {
    * Instruments are cached by type and normalized (lowercase) name.
    *
    *
+   * @template {Instrument} T
    * @param {string} name - Instrument name (will be normalized to lowercase)
    * @param {string} type - Instrument type (e.g., 'counter', 'histogram', 'gauge')
-   * @param {Function} InstrumentClass - Constructor for the instrument type
-   * @param {MetricOptions} [options] - Instrument options (description, unit, etc.)
-   * @returns {Instrument} The instrument instance (new or cached)
+   * @param {new (name: string, options: object, instrumentationScope: InstrumentationScope,
+   *   reader: object) => T} InstrumentClass - Constructor for the instrument type
+   * @param {MetricOptions} options - Instrument options (description, unit, etc.)
+   * @returns {T} The instrument instance (new or cached)
    */
   #getOrCreateInstrument (name, type, InstrumentClass, options) {
     const normalizedName = name.toLowerCase()

package/packages/dd-trace/src/opentelemetry/metrics/otlp_transformer.js

@@ -198,7 +198,7 @@ class OtlpTransformer extends OtlpTransformerBase {
     if (isJson) {
       dataPoint.startTimeUnixNano = String(dataPoint.startTimeUnixNano)
       dataPoint.timeUnixNano = String(dataPoint.timeUnixNano)
-      dataPoint.count = dataPoint.count || 0
+      dataPoint.count ||= 0
     }
 
     return dataPoint

package/packages/dd-trace/src/opentelemetry/metrics/periodic_metric_reader.js

@@ -109,7 +109,7 @@ class PeriodicMetricReader {
   /**
    * Creates a new PeriodicMetricReader instance.
    *
-   * @param {OtlpHttpMetricExporter} exporter - Metric exporter for sending to Datadog Agent
+   * @param {import('./otlp_http_metric_exporter')} exporter - Metric exporter for sending to Datadog Agent
    * @param {number} exportInterval - Export interval in milliseconds
    * @param {string} temporalityPreference - Temporality preference: DELTA, CUMULATIVE, or LOWMEMORY
    * @param {number} maxBatchedQueueSize - Maximum number of measurements to queue before dropping
@@ -253,7 +253,8 @@ class PeriodicMetricReader {
   #collectAndExport (callback = () => {}) {
     // Atomically drain measurements for export. New measurements can be recorded
     // during export without interfering with this batch.
-    const allMeasurements = this.#measurements.splice(0)
+    const allMeasurements = this.#measurements
+    this.#measurements = []
 
     for (const instrument of this.observableInstruments) {
       const observableMeasurements = instrument.collect()

package/packages/dd-trace/src/opentelemetry/span.js

@@ -38,6 +38,10 @@ function hrTimeToMilliseconds (hrTime) {
 /**
  * Several of these attributes are not yet supported by the Node.js OTel API.
  * We check for old equivalents where we can, but not all had equivalents.
+ *
+ * @param {string | undefined} spanName
+ * @param {import('@opentelemetry/api').SpanKind} kind
+ * @param {import('@opentelemetry/api').Attributes} attributes
  */
 function spanNameMapper (spanName, kind, attributes) {
   if (spanName) return spanName

package/packages/dd-trace/src/opentracing/span.js

@@ -440,7 +440,7 @@ class DatadogSpan {
       }
     }
 
-    spanContext._trace.ticks = spanContext._trace.ticks || now()
+    spanContext._trace.ticks ||= now()
     if (startTime) {
       spanContext._trace.startTime = startTime
     }

package/packages/dd-trace/src/opentracing/span_context.js

@@ -8,7 +8,7 @@ const TRACE_ID_128 = '_dd.p.tid'
 
 class DatadogSpanContext {
   constructor (props) {
-    props = props || {}
+    props ||= {}
 
     this._traceId = props.traceId
     this._spanId = props.spanId