@dexto/core 1.1.10 → 1.2.0

package/dist/telemetry/telemetry.cjs

@@ -0,0 +1,228 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  Telemetry: () => Telemetry
+});
+module.exports = __toCommonJS(telemetry_exports);
+var import_api = require("@opentelemetry/api");
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_exporter_trace_otlp_grpc = require("@opentelemetry/exporter-trace-otlp-grpc");
+var import_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var import_exporters = require("./exporters.js");
+var import_logger = require("../logger/logger.js");
+class Telemetry {
+  tracer = import_api.trace.getTracer("dexto");
+  name = "dexto-service";
+  _isInitialized = false;
+  _sdk;
+  static _initPromise;
+  static _signalHandlers;
+  constructor(config, enabled, sdk) {
+    const serviceName = config.serviceName ?? "dexto-service";
+    const tracerName = config.tracerName ?? serviceName;
+    this.name = serviceName;
+    this.tracer = import_api.trace.getTracer(tracerName);
+    if (sdk) {
+      this._sdk = sdk;
+    }
+    this._isInitialized = enabled && !!sdk;
+  }
+  static buildTraceExporter(config) {
+    const e = config?.export;
+    if (!e || e.type === "console") {
+      return new import_sdk_trace_base.ConsoleSpanExporter();
+    }
+    if (e.type === "otlp") {
+      if (e.protocol === "grpc") {
+        const options2 = {};
+        if (e.endpoint) {
+          options2.url = e.endpoint;
+        }
+        return new import_exporter_trace_otlp_grpc.OTLPTraceExporter(options2);
+      }
+      const options = {};
+      if (e.endpoint) {
+        options.url = e.endpoint;
+      }
+      if (e.headers) {
+        options.headers = e.headers;
+      }
+      return new import_exporter_trace_otlp_http.OTLPTraceExporter(options);
+    }
+    return new import_sdk_trace_base.ConsoleSpanExporter();
+  }
+  /**
+   * Initialize telemetry with the given configuration
+   * @param config - Optional telemetry configuration object
+   * @param exporter - Optional custom span exporter (overrides config.export, useful for testing)
+   * @returns Telemetry instance that can be used for tracing
+   */
+  static async init(config = {}, exporter) {
+    try {
+      if (globalThis.__TELEMETRY__) return globalThis.__TELEMETRY__;
+      if (Telemetry._initPromise) return Telemetry._initPromise;
+      Telemetry._initPromise = (async () => {
+        if (!globalThis.__TELEMETRY__) {
+          const enabled = config.enabled !== false;
+          let sdk;
+          if (enabled) {
+            const resource = new import_resources.Resource({
+              [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName ?? "dexto-service"
+            });
+            const spanExporter = exporter || Telemetry.buildTraceExporter(config);
+            const traceExporter = spanExporter instanceof import_exporters.CompositeExporter ? spanExporter : new import_exporters.CompositeExporter([spanExporter]);
+            sdk = new import_sdk_node.NodeSDK({
+              resource,
+              traceExporter,
+              instrumentations: [(0, import_auto_instrumentations_node.getNodeAutoInstrumentations)()]
+            });
+            await sdk.start();
+            const sigterm = () => {
+              void sdk?.shutdown();
+            };
+            const sigint = () => {
+              void sdk?.shutdown();
+            };
+            process.once("SIGTERM", sigterm);
+            process.once("SIGINT", sigint);
+            Telemetry._signalHandlers = { sigterm, sigint };
+          }
+          globalThis.__TELEMETRY__ = new Telemetry(config, enabled, sdk);
+        }
+        return globalThis.__TELEMETRY__;
+      })();
+      return Telemetry._initPromise;
+    } catch (error) {
+      const wrappedError = new Error(
+        `Failed to initialize telemetry: ${error instanceof Error ? error.message : String(error)}`
+      );
+      Telemetry._initPromise = void 0;
+      throw wrappedError;
+    }
+  }
+  static getActiveSpan() {
+    const span = import_api.trace.getActiveSpan();
+    return span;
+  }
+  /**
+   * Get the global telemetry instance
+   * @throws {Error} If telemetry has not been initialized
+   * @returns {Telemetry} The global telemetry instance
+   */
+  static get() {
+    if (!globalThis.__TELEMETRY__) {
+      throw new Error("Telemetry not initialized");
+    }
+    return globalThis.__TELEMETRY__;
+  }
+  /**
+   * Check if global telemetry instance exists
+   * @returns True if telemetry has been initialized, false otherwise
+   */
+  static hasGlobalInstance() {
+    return globalThis.__TELEMETRY__ !== void 0;
+  }
+  /**
+   * Shutdown global telemetry instance
+   * Used during agent switching to cleanly shutdown old agent's telemetry
+   * before initializing new agent's telemetry with potentially different config
+   * @returns Promise that resolves when shutdown is complete
+   */
+  static async shutdownGlobal() {
+    if (globalThis.__TELEMETRY__) {
+      await globalThis.__TELEMETRY__.shutdown();
+      globalThis.__TELEMETRY__ = void 0;
+    }
+    Telemetry._initPromise = void 0;
+  }
+  /**
+   * Checks if the Telemetry instance has been successfully initialized.
+   * @returns True if the instance is initialized, false otherwise.
+   */
+  isInitialized() {
+    return this._isInitialized;
+  }
+  static setBaggage(baggage, ctx = import_api.context.active()) {
+    const currentBaggage = Object.fromEntries(
+      import_api.propagation.getBaggage(ctx)?.getAllEntries() ?? []
+    );
+    const newCtx = import_api.propagation.setBaggage(
+      ctx,
+      import_api.propagation.createBaggage({
+        ...currentBaggage,
+        ...baggage
+      })
+    );
+    return newCtx;
+  }
+  static withContext(ctx, fn) {
+    return import_api.context.with(ctx, fn);
+  }
+  /**
+   * Forces pending spans to be exported immediately.
+   * Useful for testing to ensure spans are available in exporters.
+   */
+  async forceFlush() {
+    if (this._isInitialized) {
+      const provider = import_api.trace.getTracerProvider();
+      if (provider && typeof provider.forceFlush === "function") {
+        await provider.forceFlush();
+      }
+    }
+  }
+  /**
+   * Shuts down the OpenTelemetry SDK, flushing any pending spans.
+   * This should be called before the application exits.
+   *
+   * Uses two-phase shutdown:
+   * 1. Best-effort flush - Try to export pending spans (can fail if backend unavailable)
+   * 2. Force cleanup - Always clear global state to allow re-initialization
+   *
+   * This ensures agent switching works even when telemetry export fails.
+   */
+  async shutdown() {
+    if (this._sdk) {
+      try {
+        await this._sdk.shutdown();
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        import_logger.logger.warn(`Telemetry shutdown failed to flush spans (non-blocking): ${errorMsg}`);
+      } finally {
+        this._isInitialized = false;
+        globalThis.__TELEMETRY__ = void 0;
+        if (Telemetry._signalHandlers) {
+          process.off("SIGTERM", Telemetry._signalHandlers.sigterm);
+          process.off("SIGINT", Telemetry._signalHandlers.sigint);
+          Telemetry._signalHandlers = void 0;
+        }
+        this._sdk = void 0;
+        Telemetry._initPromise = void 0;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Telemetry
+});

package/dist/telemetry/telemetry.d.ts

@@ -0,0 +1,74 @@
+import type { Tracer, Context, BaggageEntry } from '@opentelemetry/api';
+import type { OtelConfiguration } from './schemas.js';
+declare global {
+    var __TELEMETRY__: Telemetry | undefined;
+}
+/**
+ * TODO (Telemetry): enhancements
+ *   - Implement sampling strategies (ratio-based, parent-based, always-on/off)
+ *   - Add custom span processors for filtering/enrichment
+ *   - Support context propagation across A2A (agent-to-agent) calls
+ *   - Add cost tracking per trace (token costs, API costs)
+ *   - Add static shutdownGlobal() method for agent switching
+ *   See feature-plans/telemetry.md for details
+ */
+export declare class Telemetry {
+    tracer: Tracer;
+    name: string;
+    private _isInitialized;
+    private _sdk?;
+    private static _initPromise?;
+    private static _signalHandlers?;
+    private constructor();
+    private static buildTraceExporter;
+    /**
+     * Initialize telemetry with the given configuration
+     * @param config - Optional telemetry configuration object
+     * @param exporter - Optional custom span exporter (overrides config.export, useful for testing)
+     * @returns Telemetry instance that can be used for tracing
+     */
+    static init(config?: OtelConfiguration, exporter?: import('@opentelemetry/sdk-trace-base').SpanExporter): Promise<Telemetry>;
+    static getActiveSpan(): import("@opentelemetry/api").Span | undefined;
+    /**
+     * Get the global telemetry instance
+     * @throws {Error} If telemetry has not been initialized
+     * @returns {Telemetry} The global telemetry instance
+     */
+    static get(): Telemetry;
+    /**
+     * Check if global telemetry instance exists
+     * @returns True if telemetry has been initialized, false otherwise
+     */
+    static hasGlobalInstance(): boolean;
+    /**
+     * Shutdown global telemetry instance
+     * Used during agent switching to cleanly shutdown old agent's telemetry
+     * before initializing new agent's telemetry with potentially different config
+     * @returns Promise that resolves when shutdown is complete
+     */
+    static shutdownGlobal(): Promise<void>;
+    /**
+     * Checks if the Telemetry instance has been successfully initialized.
+     * @returns True if the instance is initialized, false otherwise.
+     */
+    isInitialized(): boolean;
+    static setBaggage(baggage: Record<string, BaggageEntry>, ctx?: Context): Context;
+    static withContext(ctx: Context, fn: () => void): void;
+    /**
+     * Forces pending spans to be exported immediately.
+     * Useful for testing to ensure spans are available in exporters.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Shuts down the OpenTelemetry SDK, flushing any pending spans.
+     * This should be called before the application exits.
+     *
+     * Uses two-phase shutdown:
+     * 1. Best-effort flush - Try to export pending spans (can fail if backend unavailable)
+     * 2. Force cleanup - Always clear global state to allow re-initialization
+     *
+     * This ensures agent switching works even when telemetry export fails.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/telemetry/telemetry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAYtD,OAAO,CAAC,MAAM,CAAC;IACX,IAAI,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;GAQG;AACH,qBAAa,SAAS;IACX,MAAM,EAAE,MAAM,CAA4B;IACjD,IAAI,EAAE,MAAM,CAAmB;IAC/B,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,IAAI,CAAC,CAAsB;IACnC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAiC;IAC7D,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAA0D;IAEzF,OAAO;IAYP,OAAO,CAAC,MAAM,CAAC,kBAAkB;IA0BjC;;;;;OAKG;WACU,IAAI,CACb,MAAM,GAAE,iBAAsB,EAC9B,QAAQ,CAAC,EAAE,OAAO,+BAA+B,EAAE,YAAY,GAChE,OAAO,CAAC,SAAS,CAAC;IA8DrB,MAAM,CAAC,aAAa;IAKpB;;;;OAIG;IACH,MAAM,CAAC,GAAG,IAAI,SAAS;IAOvB;;;OAGG;IACH,MAAM,CAAC,iBAAiB,IAAI,OAAO;IAInC;;;;;OAKG;WACU,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5C;;;OAGG;IACI,aAAa,IAAI,OAAO;IAI/B,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,GAAE,OAA8B;IAc5F,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,IAAI;IAI/C;;;OAGG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUxC;;;;;;;;;OASG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CA8BzC"}

package/dist/telemetry/telemetry.js

@@ -0,0 +1,205 @@
+import "../chunk-C6A6W6XS.js";
+import { context as otlpContext, trace, propagation } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter as OTLPHttpExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPTraceExporter as OTLPGrpcExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { CompositeExporter } from "./exporters.js";
+import { logger } from "../logger/logger.js";
+class Telemetry {
+  tracer = trace.getTracer("dexto");
+  name = "dexto-service";
+  _isInitialized = false;
+  _sdk;
+  static _initPromise;
+  static _signalHandlers;
+  constructor(config, enabled, sdk) {
+    const serviceName = config.serviceName ?? "dexto-service";
+    const tracerName = config.tracerName ?? serviceName;
+    this.name = serviceName;
+    this.tracer = trace.getTracer(tracerName);
+    if (sdk) {
+      this._sdk = sdk;
+    }
+    this._isInitialized = enabled && !!sdk;
+  }
+  static buildTraceExporter(config) {
+    const e = config?.export;
+    if (!e || e.type === "console") {
+      return new ConsoleSpanExporter();
+    }
+    if (e.type === "otlp") {
+      if (e.protocol === "grpc") {
+        const options2 = {};
+        if (e.endpoint) {
+          options2.url = e.endpoint;
+        }
+        return new OTLPGrpcExporter(options2);
+      }
+      const options = {};
+      if (e.endpoint) {
+        options.url = e.endpoint;
+      }
+      if (e.headers) {
+        options.headers = e.headers;
+      }
+      return new OTLPHttpExporter(options);
+    }
+    return new ConsoleSpanExporter();
+  }
+  /**
+   * Initialize telemetry with the given configuration
+   * @param config - Optional telemetry configuration object
+   * @param exporter - Optional custom span exporter (overrides config.export, useful for testing)
+   * @returns Telemetry instance that can be used for tracing
+   */
+  static async init(config = {}, exporter) {
+    try {
+      if (globalThis.__TELEMETRY__) return globalThis.__TELEMETRY__;
+      if (Telemetry._initPromise) return Telemetry._initPromise;
+      Telemetry._initPromise = (async () => {
+        if (!globalThis.__TELEMETRY__) {
+          const enabled = config.enabled !== false;
+          let sdk;
+          if (enabled) {
+            const resource = new Resource({
+              [ATTR_SERVICE_NAME]: config.serviceName ?? "dexto-service"
+            });
+            const spanExporter = exporter || Telemetry.buildTraceExporter(config);
+            const traceExporter = spanExporter instanceof CompositeExporter ? spanExporter : new CompositeExporter([spanExporter]);
+            sdk = new NodeSDK({
+              resource,
+              traceExporter,
+              instrumentations: [getNodeAutoInstrumentations()]
+            });
+            await sdk.start();
+            const sigterm = () => {
+              void sdk?.shutdown();
+            };
+            const sigint = () => {
+              void sdk?.shutdown();
+            };
+            process.once("SIGTERM", sigterm);
+            process.once("SIGINT", sigint);
+            Telemetry._signalHandlers = { sigterm, sigint };
+          }
+          globalThis.__TELEMETRY__ = new Telemetry(config, enabled, sdk);
+        }
+        return globalThis.__TELEMETRY__;
+      })();
+      return Telemetry._initPromise;
+    } catch (error) {
+      const wrappedError = new Error(
+        `Failed to initialize telemetry: ${error instanceof Error ? error.message : String(error)}`
+      );
+      Telemetry._initPromise = void 0;
+      throw wrappedError;
+    }
+  }
+  static getActiveSpan() {
+    const span = trace.getActiveSpan();
+    return span;
+  }
+  /**
+   * Get the global telemetry instance
+   * @throws {Error} If telemetry has not been initialized
+   * @returns {Telemetry} The global telemetry instance
+   */
+  static get() {
+    if (!globalThis.__TELEMETRY__) {
+      throw new Error("Telemetry not initialized");
+    }
+    return globalThis.__TELEMETRY__;
+  }
+  /**
+   * Check if global telemetry instance exists
+   * @returns True if telemetry has been initialized, false otherwise
+   */
+  static hasGlobalInstance() {
+    return globalThis.__TELEMETRY__ !== void 0;
+  }
+  /**
+   * Shutdown global telemetry instance
+   * Used during agent switching to cleanly shutdown old agent's telemetry
+   * before initializing new agent's telemetry with potentially different config
+   * @returns Promise that resolves when shutdown is complete
+   */
+  static async shutdownGlobal() {
+    if (globalThis.__TELEMETRY__) {
+      await globalThis.__TELEMETRY__.shutdown();
+      globalThis.__TELEMETRY__ = void 0;
+    }
+    Telemetry._initPromise = void 0;
+  }
+  /**
+   * Checks if the Telemetry instance has been successfully initialized.
+   * @returns True if the instance is initialized, false otherwise.
+   */
+  isInitialized() {
+    return this._isInitialized;
+  }
+  static setBaggage(baggage, ctx = otlpContext.active()) {
+    const currentBaggage = Object.fromEntries(
+      propagation.getBaggage(ctx)?.getAllEntries() ?? []
+    );
+    const newCtx = propagation.setBaggage(
+      ctx,
+      propagation.createBaggage({
+        ...currentBaggage,
+        ...baggage
+      })
+    );
+    return newCtx;
+  }
+  static withContext(ctx, fn) {
+    return otlpContext.with(ctx, fn);
+  }
+  /**
+   * Forces pending spans to be exported immediately.
+   * Useful for testing to ensure spans are available in exporters.
+   */
+  async forceFlush() {
+    if (this._isInitialized) {
+      const provider = trace.getTracerProvider();
+      if (provider && typeof provider.forceFlush === "function") {
+        await provider.forceFlush();
+      }
+    }
+  }
+  /**
+   * Shuts down the OpenTelemetry SDK, flushing any pending spans.
+   * This should be called before the application exits.
+   *
+   * Uses two-phase shutdown:
+   * 1. Best-effort flush - Try to export pending spans (can fail if backend unavailable)
+   * 2. Force cleanup - Always clear global state to allow re-initialization
+   *
+   * This ensures agent switching works even when telemetry export fails.
+   */
+  async shutdown() {
+    if (this._sdk) {
+      try {
+        await this._sdk.shutdown();
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.warn(`Telemetry shutdown failed to flush spans (non-blocking): ${errorMsg}`);
+      } finally {
+        this._isInitialized = false;
+        globalThis.__TELEMETRY__ = void 0;
+        if (Telemetry._signalHandlers) {
+          process.off("SIGTERM", Telemetry._signalHandlers.sigterm);
+          process.off("SIGINT", Telemetry._signalHandlers.sigint);
+          Telemetry._signalHandlers = void 0;
+        }
+        this._sdk = void 0;
+        Telemetry._initPromise = void 0;
+      }
+    }
+  }
+}
+export {
+  Telemetry
+};

package/dist/telemetry/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/telemetry/types.d.ts

@@ -0,0 +1,22 @@
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+/**
+ * Trace data structure for storage/retrieval
+ * Used by telemetry storage exporters for persisting trace data
+ */
+export type Trace = {
+    id: string;
+    parentSpanId: string;
+    name: string;
+    traceId: string;
+    scope: string;
+    kind: ReadableSpan['kind'];
+    attributes: ReadableSpan['attributes'];
+    status: ReadableSpan['status'];
+    events: ReadableSpan['events'];
+    links: ReadableSpan['links'];
+    other: Record<string, any>;
+    startTime: number;
+    endTime: number;
+    createdAt: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/telemetry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/telemetry/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,KAAK,GAAG;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC3B,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;IACvC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC/B,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC/B,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/telemetry/utils.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  addBaggageAttributesToSpan: () => addBaggageAttributesToSpan,
+  getBaggageValues: () => getBaggageValues,
+  hasActiveTelemetry: () => hasActiveTelemetry
+});
+module.exports = __toCommonJS(utils_exports);
+var import_api = require("@opentelemetry/api");
+var import_telemetry = require("./telemetry.js");
+var import_logger = require("../logger/index.js");
+function hasActiveTelemetry() {
+  import_logger.logger.silly("hasActiveTelemetry called.");
+  try {
+    const telemetryInstance = import_telemetry.Telemetry.get();
+    const isActive = telemetryInstance.isInitialized();
+    import_logger.logger.silly(`hasActiveTelemetry: Telemetry is initialized: ${isActive}`);
+    return isActive;
+  } catch (error) {
+    import_logger.logger.silly(
+      `hasActiveTelemetry: Telemetry not active or initialized. Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+function getBaggageValues(ctx) {
+  import_logger.logger.silly("getBaggageValues called.");
+  const currentBaggage = import_api.propagation.getBaggage(ctx);
+  const requestId = currentBaggage?.getEntry("http.request_id")?.value;
+  const componentName = currentBaggage?.getEntry("componentName")?.value;
+  const runId = currentBaggage?.getEntry("runId")?.value;
+  const threadId = currentBaggage?.getEntry("threadId")?.value;
+  const resourceId = currentBaggage?.getEntry("resourceId")?.value;
+  import_logger.logger.silly(
+    `getBaggageValues: Extracted - requestId: ${requestId}, componentName: ${componentName}, runId: ${runId}, threadId: ${threadId}, resourceId: ${resourceId}`
+  );
+  return {
+    requestId,
+    componentName,
+    runId,
+    threadId,
+    resourceId
+  };
+}
+function addBaggageAttributesToSpan(span, ctx) {
+  import_logger.logger.debug("addBaggageAttributesToSpan called.");
+  const { requestId, componentName, runId, threadId, resourceId } = getBaggageValues(ctx);
+  if (componentName) {
+    span.setAttribute("componentName", componentName);
+  }
+  if (runId) {
+    span.setAttribute("runId", runId);
+  }
+  if (requestId) {
+    span.setAttribute("http.request_id", requestId);
+  }
+  if (threadId) {
+    span.setAttribute("threadId", threadId);
+  }
+  if (resourceId) {
+    span.setAttribute("resourceId", resourceId);
+  }
+  import_logger.logger.debug("addBaggageAttributesToSpan: Baggage attributes added to span.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBaggageAttributesToSpan,
+  getBaggageValues,
+  hasActiveTelemetry
+});

package/dist/telemetry/utils.d.ts

@@ -0,0 +1,21 @@
+import type { Context, Span } from '@opentelemetry/api';
+export declare function hasActiveTelemetry(): boolean;
+/**
+ * Get baggage values from context
+ * @param ctx The context to get baggage values from
+ * @returns
+ */
+export declare function getBaggageValues(ctx: Context): {
+    requestId: string | undefined;
+    componentName: string | undefined;
+    runId: string | undefined;
+    threadId: string | undefined;
+    resourceId: string | undefined;
+};
+/**
+ * Attaches baggage values from the given context to the provided span as attributes.
+ * @param span The OpenTelemetry Span to add attributes to.
+ * @param ctx The OpenTelemetry Context from which to extract baggage values.
+ */
+export declare function addBaggageAttributesToSpan(span: Span, ctx: Context): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/telemetry/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/telemetry/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAKxD,wBAAgB,kBAAkB,IAAI,OAAO,CAa5C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO;;;;;;EAkB5C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAoBzE"}