@openclaw/diagnostics-otel 2026.7.2-beta.4 → 2026.7.2-beta.7

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/MultiSpanProcessor.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@opentelemetry/api';
+import type { ReadableSpan } from './export/ReadableSpan';
+import type { Span } from './Span';
+import type { SpanProcessor } from './SpanProcessor';
+/**
+ * Implementation of the {@link SpanProcessor} that simply forwards all
+ * received events to a list of {@link SpanProcessor}s.
+ */
+export declare class MultiSpanProcessor implements SpanProcessor {
+    private readonly _spanProcessors;
+    constructor(spanProcessors: SpanProcessor[]);
+    forceFlush(): Promise<void>;
+    onStart(span: Span, context: Context): void;
+    onEnding(span: Span): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=MultiSpanProcessor.d.ts.map

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/MultiSpanProcessor.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { globalErrorHandler } from '@opentelemetry/core';
+/**
+ * Implementation of the {@link SpanProcessor} that simply forwards all
+ * received events to a list of {@link SpanProcessor}s.
+ */
+export class MultiSpanProcessor {
+    _spanProcessors;
+    constructor(spanProcessors) {
+        this._spanProcessors = spanProcessors;
+    }
+    forceFlush() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+            promises.push(spanProcessor.forceFlush());
+        }
+        return new Promise(resolve => {
+            Promise.all(promises)
+                .then(() => {
+                resolve();
+            })
+                .catch(error => {
+                globalErrorHandler(error || new Error('MultiSpanProcessor: forceFlush failed'));
+                resolve();
+            });
+        });
+    }
+    onStart(span, context) {
+        for (const spanProcessor of this._spanProcessors) {
+            spanProcessor.onStart(span, context);
+        }
+    }
+    onEnding(span) {
+        for (const spanProcessor of this._spanProcessors) {
+            if (spanProcessor.onEnding) {
+                spanProcessor.onEnding(span);
+            }
+        }
+    }
+    onEnd(span) {
+        for (const spanProcessor of this._spanProcessors) {
+            spanProcessor.onEnd(span);
+        }
+    }
+    shutdown() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+            promises.push(spanProcessor.shutdown());
+        }
+        return new Promise((resolve, reject) => {
+            Promise.all(promises).then(() => {
+                resolve();
+            }, reject);
+        });
+    }
+}
+//# sourceMappingURL=MultiSpanProcessor.js.map

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/MultiSpanProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiSpanProcessor.js","sourceRoot":"","sources":["../../src/MultiSpanProcessor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAKzD;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IACZ,eAAe,CAAkB;IAClD,YAAY,cAA+B;QACzC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;IACxC,CAAC;IAED,UAAU;QACR,MAAM,QAAQ,GAAoB,EAAE,CAAC;QAErC,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAC,CAAC;SAC3C;QACD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;YAC3B,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;iBAClB,IAAI,CAAC,GAAG,EAAE;gBACT,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC;iBACD,KAAK,CAAC,KAAK,CAAC,EAAE;gBACb,kBAAkB,CAChB,KAAK,IAAI,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAC5D,CAAC;gBACF,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,CAAC,IAAU,EAAE,OAAgB;QAClC,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;SACtC;IACH,CAAC;IAED,QAAQ,CAAC,IAAU;QACjB,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,IAAI,aAAa,CAAC,QAAQ,EAAE;gBAC1B,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;aAC9B;SACF;IACH,CAAC;IAED,KAAK,CAAC,IAAkB;QACtB,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SAC3B;IACH,CAAC;IAED,QAAQ;QACN,MAAM,QAAQ,GAAoB,EAAE,CAAC;QAErC,KAAK,MAAM,aAAa,IAAI,IAAI,CAAC,eAAe,EAAE;YAChD,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC;SACzC;QACD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC9B,OAAO,EAAE,CAAC;YACZ,CAAC,EAAE,MAAM,CAAC,CAAC;QACb,CAAC,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type { Context } from '@opentelemetry/api';\nimport { globalErrorHandler } from '@opentelemetry/core';\nimport type { ReadableSpan } from './export/ReadableSpan';\nimport type { Span } from './Span';\nimport type { SpanProcessor } from './SpanProcessor';\n\n/**\n * Implementation of the {@link SpanProcessor} that simply forwards all\n * received events to a list of {@link SpanProcessor}s.\n */\nexport class MultiSpanProcessor implements SpanProcessor {\n  private readonly _spanProcessors: SpanProcessor[];\n  constructor(spanProcessors: SpanProcessor[]) {\n    this._spanProcessors = spanProcessors;\n  }\n\n  forceFlush(): Promise<void> {\n    const promises: Promise<void>[] = [];\n\n    for (const spanProcessor of this._spanProcessors) {\n      promises.push(spanProcessor.forceFlush());\n    }\n    return new Promise(resolve => {\n      Promise.all(promises)\n        .then(() => {\n          resolve();\n        })\n        .catch(error => {\n          globalErrorHandler(\n            error || new Error('MultiSpanProcessor: forceFlush failed')\n          );\n          resolve();\n        });\n    });\n  }\n\n  onStart(span: Span, context: Context): void {\n    for (const spanProcessor of this._spanProcessors) {\n      spanProcessor.onStart(span, context);\n    }\n  }\n\n  onEnding(span: Span): void {\n    for (const spanProcessor of this._spanProcessors) {\n      if (spanProcessor.onEnding) {\n        spanProcessor.onEnding(span);\n      }\n    }\n  }\n\n  onEnd(span: ReadableSpan): void {\n    for (const spanProcessor of this._spanProcessors) {\n      spanProcessor.onEnd(span);\n    }\n  }\n\n  shutdown(): Promise<void> {\n    const promises: Promise<void>[] = [];\n\n    for (const spanProcessor of this._spanProcessors) {\n      promises.push(spanProcessor.shutdown());\n    }\n    return new Promise((resolve, reject) => {\n      Promise.all(promises).then(() => {\n        resolve();\n      }, reject);\n    });\n  }\n}\n"]}

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/Sampler.d.ts

@@ -0,0 +1,70 @@
+import type { Context, Link, Attributes, SpanKind, TraceState } from '@opentelemetry/api';
+/**
+ * A sampling decision that determines how a {@link Span} will be recorded
+ * and collected.
+ */
+export declare enum SamplingDecision {
+    /**
+     * `Span.isRecording() === false`, span will not be recorded and all events
+     * and attributes will be dropped.
+     */
+    NOT_RECORD = 0,
+    /**
+     * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+     * MUST NOT be set.
+     */
+    RECORD = 1,
+    /**
+     * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+     * MUST be set.
+     */
+    RECORD_AND_SAMPLED = 2
+}
+/**
+ * A sampling result contains a decision for a {@link Span} and additional
+ * attributes the sampler would like to added to the Span.
+ */
+export interface SamplingResult {
+    /**
+     * A sampling decision, refer to {@link SamplingDecision} for details.
+     */
+    decision: SamplingDecision;
+    /**
+     * The list of attributes returned by SamplingResult MUST be immutable.
+     * Caller may call {@link Sampler}.shouldSample any number of times and
+     * can safely cache the returned value.
+     */
+    attributes?: Readonly<Attributes>;
+    /**
+     * A {@link TraceState} that will be associated with the {@link Span} through
+     * the new {@link SpanContext}. Samplers SHOULD return the TraceState from
+     * the passed-in {@link Context} if they do not intend to change it. Leaving
+     * the value undefined will also leave the TraceState unchanged.
+     */
+    traceState?: TraceState;
+}
+/**
+ * This interface represent a sampler. Sampling is a mechanism to control the
+ * noise and overhead introduced by OpenTelemetry by reducing the number of
+ * samples of traces collected and sent to the backend.
+ */
+export interface Sampler {
+    /**
+     * Checks whether span needs to be created and tracked.
+     *
+     * @param context Parent Context which may contain a span.
+     * @param traceId of the span to be created. It can be different from the
+     *     traceId in the {@link SpanContext}. Typically in situations when the
+     *     span to be created starts a new trace.
+     * @param spanName of the span to be created.
+     * @param spanKind of the span to be created.
+     * @param attributes Initial set of Attributes for the Span being constructed.
+     * @param links Collection of links that will be associated with the Span to
+     *     be created. Typically useful for batch operations.
+     * @returns a {@link SamplingResult}.
+     */
+    shouldSample(context: Context, traceId: string, spanName: string, spanKind: SpanKind, attributes: Attributes, links: Link[]): SamplingResult;
+    /** Returns the sampler name or short description with the configuration. */
+    toString(): string;
+}
+//# sourceMappingURL=Sampler.d.ts.map

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/Sampler.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A sampling decision that determines how a {@link Span} will be recorded
+ * and collected.
+ */
+export var SamplingDecision;
+(function (SamplingDecision) {
+    /**
+     * `Span.isRecording() === false`, span will not be recorded and all events
+     * and attributes will be dropped.
+     */
+    SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD";
+    /**
+     * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
+     * MUST NOT be set.
+     */
+    SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD";
+    /**
+     * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
+     * MUST be set.
+     */
+    SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+})(SamplingDecision || (SamplingDecision = {}));
+//# sourceMappingURL=Sampler.js.map

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/Sampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sampler.js","sourceRoot":"","sources":["../../src/Sampler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH;;;GAGG;AACH,MAAM,CAAN,IAAY,gBAgBX;AAhBD,WAAY,gBAAgB;IAC1B;;;OAGG;IACH,mEAAU,CAAA;IACV;;;OAGG;IACH,2DAAM,CAAA;IACN;;;OAGG;IACH,mFAAkB,CAAA;AACpB,CAAC,EAhBW,gBAAgB,KAAhB,gBAAgB,QAgB3B","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport type {\n  Context,\n  Link,\n  Attributes,\n  SpanKind,\n  TraceState,\n} from '@opentelemetry/api';\n\n/**\n * A sampling decision that determines how a {@link Span} will be recorded\n * and collected.\n */\nexport enum SamplingDecision {\n  /**\n   * `Span.isRecording() === false`, span will not be recorded and all events\n   * and attributes will be dropped.\n   */\n  NOT_RECORD,\n  /**\n   * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}\n   * MUST NOT be set.\n   */\n  RECORD,\n  /**\n   * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}\n   * MUST be set.\n   */\n  RECORD_AND_SAMPLED,\n}\n\n/**\n * A sampling result contains a decision for a {@link Span} and additional\n * attributes the sampler would like to added to the Span.\n */\nexport interface SamplingResult {\n  /**\n   * A sampling decision, refer to {@link SamplingDecision} for details.\n   */\n  decision: SamplingDecision;\n  /**\n   * The list of attributes returned by SamplingResult MUST be immutable.\n   * Caller may call {@link Sampler}.shouldSample any number of times and\n   * can safely cache the returned value.\n   */\n  attributes?: Readonly<Attributes>;\n  /**\n   * A {@link TraceState} that will be associated with the {@link Span} through\n   * the new {@link SpanContext}. Samplers SHOULD return the TraceState from\n   * the passed-in {@link Context} if they do not intend to change it. Leaving\n   * the value undefined will also leave the TraceState unchanged.\n   */\n  traceState?: TraceState;\n}\n\n/**\n * This interface represent a sampler. Sampling is a mechanism to control the\n * noise and overhead introduced by OpenTelemetry by reducing the number of\n * samples of traces collected and sent to the backend.\n */\nexport interface Sampler {\n  /**\n   * Checks whether span needs to be created and tracked.\n   *\n   * @param context Parent Context which may contain a span.\n   * @param traceId of the span to be created. It can be different from the\n   *     traceId in the {@link SpanContext}. Typically in situations when the\n   *     span to be created starts a new trace.\n   * @param spanName of the span to be created.\n   * @param spanKind of the span to be created.\n   * @param attributes Initial set of Attributes for the Span being constructed.\n   * @param links Collection of links that will be associated with the Span to\n   *     be created. Typically useful for batch operations.\n   * @returns a {@link SamplingResult}.\n   */\n  shouldSample(\n    context: Context,\n    traceId: string,\n    spanName: string,\n    spanKind: SpanKind,\n    attributes: Attributes,\n    links: Link[]\n  ): SamplingResult;\n\n  /** Returns the sampler name or short description with the configuration. */\n  toString(): string;\n}\n"]}

package/node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/sdk-trace/build/esm/Span.d.ts

@@ -0,0 +1,102 @@
+import type { Context, Exception, HrTime, Link, Span as APISpan, SpanOptions as APISpanOptions, Attributes, AttributeValue, SpanContext, SpanKind, SpanStatus, TimeInput } from '@opentelemetry/api';
+import type { InstrumentationScope } from '@opentelemetry/core';
+import type { Resource } from '@opentelemetry/resources';
+import type { ReadableSpan } from './export/ReadableSpan';
+import type { SpanProcessor } from './SpanProcessor';
+import type { TimedEvent } from './TimedEvent';
+import type { SpanLimits } from './types';
+import type { InspectFn, InspectStylizeOptions } from './inspect';
+import { inspectCustom } from './inspect';
+/**
+ * This type provides the properties of @link{ReadableSpan} at the same time
+ * of the Span API
+ */
+export type Span = APISpan & ReadableSpan;
+type SpanOptions = Omit<APISpanOptions, 'root'> & {
+    resource: Resource;
+    scope: InstrumentationScope;
+    context: Context;
+    spanContext: SpanContext;
+    name: string;
+    kind: SpanKind;
+    parentSpanContext?: SpanContext;
+    spanLimits: SpanLimits;
+    spanProcessor: SpanProcessor;
+    recordEndMetrics?: () => void;
+};
+/**
+ * This class represents a span.
+ */
+export declare class SpanImpl implements Span {
+    private readonly _spanContext;
+    readonly kind: SpanKind;
+    readonly parentSpanContext?: SpanContext;
+    readonly attributes: Attributes;
+    readonly links: Link[];
+    readonly events: TimedEvent[];
+    readonly startTime: HrTime;
+    readonly resource: Resource;
+    readonly instrumentationScope: InstrumentationScope;
+    private _droppedAttributesCount;
+    private _droppedEventsCount;
+    private _droppedLinksCount;
+    private _attributesCount;
+    name: string;
+    status: SpanStatus;
+    endTime: HrTime;
+    private _ended;
+    private _duration;
+    private readonly _spanProcessor;
+    private readonly _spanLimits;
+    private readonly _attributeValueLengthLimit;
+    private readonly _recordEndMetrics?;
+    private readonly _performanceStartTime;
+    private readonly _performanceOffset;
+    private readonly _startTimeProvided;
+    /**
+     * Constructs a new SpanImpl instance.
+     */
+    constructor(opts: SpanOptions);
+    spanContext(): SpanContext;
+    setAttribute(key: string, value?: AttributeValue): this;
+    setAttributes(attributes: Attributes): this;
+    /**
+     *
+     * @param name Span Name
+     * @param [attributesOrStartTime] Span attributes or start time
+     *     if type is {@type TimeInput} and 3rd param is undefined
+     * @param [timeStamp] Specified time stamp for the event
+     */
+    addEvent(name: string, attributesOrStartTime?: Attributes | TimeInput, timeStamp?: TimeInput): this;
+    addLink(link: Link): this;
+    addLinks(links: Link[]): this;
+    setStatus(status: SpanStatus): this;
+    updateName(name: string): this;
+    end(endTime?: TimeInput): void;
+    private _getTime;
+    isRecording(): boolean;
+    recordException(exception: Exception, time?: TimeInput): void;
+    get duration(): HrTime;
+    get ended(): boolean;
+    get droppedAttributesCount(): number;
+    get droppedEventsCount(): number;
+    get droppedLinksCount(): number;
+    private _isSpanEnded;
+    private _truncateToLimitUtil;
+    /**
+     * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
+     * return string with truncated to {@code attributeValueLengthLimit} characters
+     *
+     * If the given attribute value is array of strings then
+     * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
+     *
+     * Otherwise return same Attribute {@code value}
+     *
+     * @param value Attribute value
+     * @returns truncated attribute value if required, otherwise same value
+     */
+    private _truncateToSize;
+    [inspectCustom](depth: number, options: InspectStylizeOptions | undefined, inspect: InspectFn | undefined): unknown;
+}
+export {};
+//# sourceMappingURL=Span.d.ts.map