@microsoft/opentelemetry 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/esm/distro/types.d.ts

@@ -1,41 +1,4 @@
-import type { Resource } from "@opentelemetry/resources";
-import type { LogRecordProcessor } from "@opentelemetry/sdk-logs";
-import type { MetricReader, ViewOptions } from "@opentelemetry/sdk-metrics";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
-import type { AzureMonitorOpenTelemetryOptions, InstrumentationOptions, BrowserSdkLoaderOptions } from "../types.js";
-import type { A365Options } from "../_a365/index.js";
-export type { InstrumentationOptions, BrowserSdkLoaderOptions, A365Options };
-/**
- * Microsoft OpenTelemetry distribution version.
- */
-export declare const MICROSOFT_OPENTELEMETRY_VERSION = "0.1.0";
-/**
- * Microsoft OpenTelemetry Options
- *
- * Top-level configuration for the Microsoft OpenTelemetry distribution.
- * Global options (resource, sampling, instrumentations, processors) live here.
- * Backend-specific options are scoped under their respective keys.
- */
-export interface MicrosoftOpenTelemetryOptions {
-    /** OpenTelemetry Resource */
-    resource?: Resource;
-    /** The rate of telemetry items tracked that should be transmitted (Default 1.0) */
-    samplingRatio?: number;
-    /** The maximum number of traces to sample per second (Default 5). Set to 0 to use samplingRatio instead. */
-    tracesPerSecond?: number;
-    /** OpenTelemetry Instrumentations configuration */
-    instrumentationOptions?: InstrumentationOptions;
-    /** An array of log record processors to register to the logger provider. */
-    logRecordProcessors?: LogRecordProcessor[];
-    /** An array of span processors to register to the tracer provider. */
-    spanProcessors?: SpanProcessor[];
-    /** An array of metric readers to register to the meter provider. */
-    metricReaders?: MetricReader[];
-    /** An array of metric views to register to the meter provider. */
-    views?: ViewOptions[];
-    /** Azure Monitor configuration. When provided, Azure Monitor export is enabled. */
-    azureMonitor?: AzureMonitorOpenTelemetryOptions;
-    /** A365 observability configuration. When provided with `enabled: true`, A365 export is enabled. */
-    a365?: A365Options;
-}
+export type { MicrosoftOpenTelemetryOptions, InstrumentationOptions, BrowserSdkLoaderOptions, } from "../types.js";
+export type { A365Options } from "../a365/index.js";
+export { MICROSOFT_OPENTELEMETRY_VERSION } from "../types.js";
 //# sourceMappingURL=types.d.ts.map

package/dist/esm/distro/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/distro/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EACV,gCAAgC,EAChC,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,YAAY,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,EAAE,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,+BAA+B,UAAU,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,WAAW,6BAA6B;IAG5C,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,mFAAmF;IACnF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4GAA4G;IAC5G,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;IAChD,4EAA4E;IAC5E,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC3C,sEAAsE;IACtE,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;IACjC,oEAAoE;IACpE,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,kEAAkE;IAClE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IAItB,mFAAmF;IACnF,YAAY,CAAC,EAAE,gCAAgC,CAAC;IAEhD,oGAAoG;IACpG,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/distro/types.ts"],"names":[],"mappings":"AAIA,YAAY,EACV,6BAA6B,EAC7B,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC"}

package/dist/esm/distro/types.js

@@ -1,7 +1,4 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-/**
- * Microsoft OpenTelemetry distribution version.
- */
-export const MICROSOFT_OPENTELEMETRY_VERSION = "0.1.0";
+export { MICROSOFT_OPENTELEMETRY_VERSION } from "../types.js";
 //# sourceMappingURL=types.js.map

package/dist/esm/distro/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/distro/types.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAelC;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,OAAO,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/distro/types.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AASlC,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC"}

package/dist/esm/genai/instrumentations/openai/index.d.ts

@@ -0,0 +1,3 @@
+export { OpenAIAgentsTraceInstrumentor } from "./openAIAgentsTraceInstrumentor.js";
+export { OpenAIAgentsTraceProcessor } from "./openAIAgentsTraceProcessor.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/genai/instrumentations/openai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/genai/instrumentations/openai/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/esm/genai/instrumentations/openai/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export { OpenAIAgentsTraceInstrumentor } from "./openAIAgentsTraceInstrumentor.js";
+export { OpenAIAgentsTraceProcessor } from "./openAIAgentsTraceProcessor.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/genai/instrumentations/openai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/genai/instrumentations/openai/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.d.ts

@@ -0,0 +1,45 @@
+import { InstrumentationConfig } from "@opentelemetry/instrumentation";
+/**
+ * Configuration options for the OpenAI Agents instrumentor.
+ */
+export interface OpenAIAgentsInstrumentationConfig extends InstrumentationConfig {
+    /**
+     * When true, the gen_ai.input.messages attribute containing LLM input
+     * messages will be suppressed and not attached to spans in InvokeAgent scopes.
+     * @default false
+     */
+    suppressInvokeAgentInput?: boolean;
+    /**
+     * Whether to enable content recording (input/output messages, tool args, etc.).
+     * @default false
+     */
+    isContentRecordingEnabled?: boolean;
+}
+/**
+ * Static wrapper for OpenAI Agents SDK tracing instrumentation.
+ *
+ * Usage:
+ * ```ts
+ * OpenAIAgentsTraceInstrumentor.instrument({ isContentRecordingEnabled: true });
+ * ```
+ */
+export declare class OpenAIAgentsTraceInstrumentor {
+    private static throwNotInitialized;
+    /**
+     * Initialize and auto-enable the OpenAI Agents instrumentation.
+     */
+    static instrument(options?: OpenAIAgentsInstrumentationConfig): void;
+    /**
+     * Enable OpenAI Agents instrumentation.
+     */
+    static enable(): void;
+    /**
+     * Disable OpenAI Agents instrumentation.
+     */
+    static disable(): void;
+    /**
+     * Reset the instrumentor instance (for testing).
+     */
+    static resetInstance(): void;
+}
+//# sourceMappingURL=openAIAgentsTraceInstrumentor.d.ts.map

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openAIAgentsTraceInstrumentor.d.ts","sourceRoot":"","sources":["../../../../../src/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,qBAAqB,EAEtB,MAAM,gCAAgC,CAAC;AAIxC;;GAEG;AACH,MAAM,WAAW,iCAAkC,SAAQ,qBAAqB;IAC9E;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;;OAGG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAuHD;;;;;;;GAOG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAOlC;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,iCAAiC,GAAG,IAAI;IAIpE;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,IAAI;IAOrB;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,IAAI;IAOtB;;OAEG;IACH,MAAM,CAAC,aAAa,IAAI,IAAI;CAG7B"}

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.js

@@ -0,0 +1,146 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Vendored from microsoft/Agent365-nodejs packages/agents-a365-observability-extensions-openai
+// Adapted: removed ObservabilityManager dependency, uses diag logger instead of A365 logger
+import { diag, trace } from "@opentelemetry/api";
+import { InstrumentationBase, } from "@opentelemetry/instrumentation";
+import { setTraceProcessors, setTracingDisabled } from "@openai/agents";
+import { OpenAIAgentsTraceProcessor } from "./openAIAgentsTraceProcessor.js";
+/**
+ * Internal singleton implementation.
+ */
+class OpenAIAgentsTraceInstrumentorImpl extends InstrumentationBase {
+    static _instance = null;
+    _hasBeenEnabled = false;
+    processor;
+    otelTracer;
+    constructor(config = {}) {
+        if (OpenAIAgentsTraceInstrumentorImpl._instance !== null) {
+            throw new Error("OpenAIAgentsTraceInstrumentor can only be instantiated once.");
+        }
+        super("microsoft-otel-openai-agents-instrumentor", "1.0.0", {
+            enabled: true,
+            ...config,
+        });
+        this.otelTracer = trace.getTracer("microsoft-otel-openai-agents", "1.0.0");
+        OpenAIAgentsTraceInstrumentorImpl._instance = this;
+        diag.info("[OpenAIAgentsTraceInstrumentor] Initialized");
+    }
+    static getInstance(config) {
+        if (!OpenAIAgentsTraceInstrumentorImpl._instance) {
+            OpenAIAgentsTraceInstrumentorImpl._instance = new OpenAIAgentsTraceInstrumentorImpl(config);
+        }
+        return OpenAIAgentsTraceInstrumentorImpl._instance;
+    }
+    static hasInstance() {
+        return OpenAIAgentsTraceInstrumentorImpl._instance !== null;
+    }
+    static resetInstance() {
+        const inst = OpenAIAgentsTraceInstrumentorImpl._instance;
+        if (inst) {
+            void inst.processor?.shutdown();
+            inst.processor = undefined;
+        }
+        OpenAIAgentsTraceInstrumentorImpl._instance = null;
+    }
+    init() {
+        return {
+            name: "@openai/agents",
+            supportedVersions: [">=0.1.5"],
+            files: [],
+        };
+    }
+    instrumentationDependencies() {
+        return ["@openai/agents >= 0.1.5"];
+    }
+    /**
+     * Enable instrumentation.
+     * Sets up the trace processor and registers it with the OpenAI Agents SDK.
+     */
+    enable() {
+        if (this._hasBeenEnabled) {
+            return;
+        }
+        this._hasBeenEnabled = true;
+        // Enable tracing in the OpenAI Agents SDK
+        setTracingDisabled(false);
+        this.processor = new OpenAIAgentsTraceProcessor(this.otelTracer, {
+            suppressInvokeAgentInput: this._config.suppressInvokeAgentInput ?? false,
+            isContentRecordingEnabled: this._config.isContentRecordingEnabled ?? false,
+        });
+        try {
+            setTraceProcessors([this.processor]);
+        }
+        catch (error) {
+            diag.error(`[OpenAIAgentsTraceInstrumentor] Failed to register trace processor: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        diag.info("[OpenAIAgentsTraceInstrumentor] Enabled OpenAI Agents instrumentation");
+        super.enable();
+    }
+    /**
+     * Disable instrumentation.
+     */
+    disable() {
+        if (this.processor) {
+            void this.processor.shutdown();
+            this.processor = undefined;
+        }
+        this._hasBeenEnabled = false;
+        try {
+            setTraceProcessors([]);
+        }
+        catch (error) {
+            diag.error(`[OpenAIAgentsTraceInstrumentor] Failed to clear trace processors: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        diag.info("[OpenAIAgentsTraceInstrumentor] Disabled OpenAI Agents instrumentation");
+        super.disable();
+    }
+    getProcessor() {
+        return this.processor;
+    }
+}
+/**
+ * Static wrapper for OpenAI Agents SDK tracing instrumentation.
+ *
+ * Usage:
+ * ```ts
+ * OpenAIAgentsTraceInstrumentor.instrument({ isContentRecordingEnabled: true });
+ * ```
+ */
+export class OpenAIAgentsTraceInstrumentor {
+    static throwNotInitialized() {
+        throw new Error("OpenAIAgentsTraceInstrumentor must be initialized first. " +
+            "Call OpenAIAgentsTraceInstrumentor.instrument() before using enable/disable.");
+    }
+    /**
+     * Initialize and auto-enable the OpenAI Agents instrumentation.
+     */
+    static instrument(options) {
+        OpenAIAgentsTraceInstrumentorImpl.getInstance(options).enable();
+    }
+    /**
+     * Enable OpenAI Agents instrumentation.
+     */
+    static enable() {
+        if (!OpenAIAgentsTraceInstrumentorImpl.hasInstance()) {
+            this.throwNotInitialized();
+        }
+        OpenAIAgentsTraceInstrumentorImpl.getInstance().enable();
+    }
+    /**
+     * Disable OpenAI Agents instrumentation.
+     */
+    static disable() {
+        if (!OpenAIAgentsTraceInstrumentorImpl.hasInstance()) {
+            this.throwNotInitialized();
+        }
+        OpenAIAgentsTraceInstrumentorImpl.getInstance().disable();
+    }
+    /**
+     * Reset the instrumentor instance (for testing).
+     */
+    static resetInstance() {
+        OpenAIAgentsTraceInstrumentorImpl.resetInstance();
+    }
+}
+//# sourceMappingURL=openAIAgentsTraceInstrumentor.js.map

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openAIAgentsTraceInstrumentor.js","sourceRoot":"","sources":["../../../../../src/genai/instrumentations/openai/openAIAgentsTraceInstrumentor.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAClC,+FAA+F;AAC/F,4FAA4F;AAE5F,OAAO,EAAE,IAAI,EAAE,KAAK,EAAU,MAAM,oBAAoB,CAAC;AACzD,OAAO,EACL,mBAAmB,GAGpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAoB,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAmB7E;;GAEG;AACH,MAAM,iCAAkC,SAAQ,mBAAsD;IAC5F,MAAM,CAAC,SAAS,GAA6C,IAAI,CAAC;IAClE,eAAe,GAAG,KAAK,CAAC;IACxB,SAAS,CAA8B;IACrC,UAAU,CAAS;IAE7B,YAAoB,SAA4C,EAAE;QAChE,IAAI,iCAAiC,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;QAClF,CAAC;QAED,KAAK,CAAC,2CAA2C,EAAE,OAAO,EAAE;YAC1D,OAAO,EAAE,IAAI;YACb,GAAG,MAAM;SACV,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC,8BAA8B,EAAE,OAAO,CAAC,CAAC;QAE3E,iCAAiC,CAAC,SAAS,GAAG,IAAI,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;IAC3D,CAAC;IAED,MAAM,CAAC,WAAW,CAChB,MAA0C;QAE1C,IAAI,CAAC,iCAAiC,CAAC,SAAS,EAAE,CAAC;YACjD,iCAAiC,CAAC,SAAS,GAAG,IAAI,iCAAiC,CAAC,MAAM,CAAC,CAAC;QAC9F,CAAC;QACD,OAAO,iCAAiC,CAAC,SAAS,CAAC;IACrD,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,OAAO,iCAAiC,CAAC,SAAS,KAAK,IAAI,CAAC;IAC9D,CAAC;IAED,MAAM,CAAC,aAAa;QAClB,MAAM,IAAI,GAAG,iCAAiC,CAAC,SAAS,CAAC;QACzD,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC;YAChC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC7B,CAAC;QACD,iCAAiC,CAAC,SAAS,GAAG,IAAI,CAAC;IACrD,CAAC;IAES,IAAI;QACZ,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,iBAAiB,EAAE,CAAC,SAAS,CAAC;YAC9B,KAAK,EAAE,EAAE;SACV,CAAC;IACJ,CAAC;IAEM,2BAA2B;QAChC,OAAO,CAAC,yBAAyB,CAAU,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACa,MAAM;QACpB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAE5B,0CAA0C;QAC1C,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAE1B,IAAI,CAAC,SAAS,GAAG,IAAI,0BAA0B,CAAC,IAAI,CAAC,UAAU,EAAE;YAC/D,wBAAwB,EAAE,IAAI,CAAC,OAAO,CAAC,wBAAwB,IAAI,KAAK;YACxE,yBAAyB,EAAE,IAAI,CAAC,OAAO,CAAC,yBAAyB,IAAI,KAAK;SAC3E,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,kBAAkB,CAAC,CAAC,IAAI,CAAC,SAA6B,CAAC,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CACR,uEAAuE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAChI,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;QACnF,KAAK,CAAC,MAAM,EAAE,CAAC;IACjB,CAAC;IAED;;OAEG;IACa,OAAO;QACrB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;YAC/B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAE7B,IAAI,CAAC;YACH,kBAAkB,CAAC,EAAE,CAAC,CAAC;QACzB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CACR,qEAAqE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC9H,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,wEAAwE,CAAC,CAAC;QACpF,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;IAEM,YAAY;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;;AAGH;;;;;;;GAOG;AACH,MAAM,OAAO,6BAA6B;IAChC,MAAM,CAAC,mBAAmB;QAChC,MAAM,IAAI,KAAK,CACb,2DAA2D;YACzD,8EAA8E,CACjF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,OAA2C;QAC3D,iCAAiC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;IAClE,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM;QACX,IAAI,CAAC,iCAAiC,CAAC,WAAW,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC;QACD,iCAAiC,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,CAAC;IAC3D,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,IAAI,CAAC,iCAAiC,CAAC,WAAW,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC;QACD,iCAAiC,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC;IAC5D,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,aAAa;QAClB,iCAAiC,CAAC,aAAa,EAAE,CAAC;IACpD,CAAC;CACF"}

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceProcessor.d.ts

@@ -0,0 +1,57 @@
+import { Tracer as OtelTracer } from "@opentelemetry/api";
+import type { Span as AgentsSpan, SpanData, Trace as AgentTrace, TracingProcessor } from "@openai/agents-core";
+/**
+ * OpenTelemetry-based trace processor for the OpenAI Agents SDK.
+ *
+ * Implements the `TracingProcessor` interface from `@openai/agents-core` so it
+ * can be registered via `setTraceProcessors()`. Every OpenAI agent span
+ * (agent invocation, function/tool call, LLM generation, response, handoff,
+ * MCP list-tools) is mapped to an OTel span with GenAI semantic convention
+ * attributes.
+ *
+ * Key behaviors:
+ * - Creates an OTel span on `onSpanStart` and ends it on `onSpanEnd`.
+ * - Maintains parent–child span relationships via trace/span ID maps.
+ * - Guards against unbounded memory with a hard cap of {@link MAX_SPANS_IN_FLIGHT}.
+ * - Content-sensitive attributes (messages, tool args) are only recorded
+ *   when `isContentRecordingEnabled` is true.
+ */
+export declare class OpenAIAgentsTraceProcessor implements TracingProcessor {
+    private static readonly MAX_HANDOFFS_IN_FLIGHT;
+    private static readonly MAX_SPANS_IN_FLIGHT;
+    private readonly tracer;
+    private readonly suppressInvokeAgentInput;
+    private readonly isContentRecordingEnabled;
+    /** Root spans keyed by trace ID. */
+    private readonly rootSpans;
+    /** Active OTel spans keyed by OpenAI span ID. */
+    private readonly otelSpans;
+    /** Context tokens for span activation. */
+    private readonly tokens;
+    /** Reverse handoff map: `${toAgent}:${traceId}` → fromAgent */
+    private readonly reverseHandoffsDict;
+    /** Span names for lookup (OTel Span doesn't expose name). */
+    private readonly spanNames;
+    constructor(tracer: OtelTracer, options?: {
+        suppressInvokeAgentInput?: boolean;
+        isContentRecordingEnabled?: boolean;
+    });
+    private isContentKey;
+    private getNewKey;
+    start(): Promise<void>;
+    onTraceStart(_trace: AgentTrace): Promise<void>;
+    onTraceEnd(trace: AgentTrace): Promise<void>;
+    onSpanStart(span: AgentsSpan<SpanData>): Promise<void>;
+    onSpanEnd(span: AgentsSpan<SpanData>): Promise<void>;
+    forceFlush(): Promise<void>;
+    shutdown(_timeout?: number): Promise<void>;
+    private processSpanData;
+    private processResponseSpanData;
+    private processGenerationSpanData;
+    private processFunctionSpanData;
+    private processMCPListToolsSpanData;
+    private processHandoffSpanData;
+    private processAgentSpanData;
+    private stampCustomParent;
+}
+//# sourceMappingURL=openAIAgentsTraceProcessor.d.ts.map

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openAIAgentsTraceProcessor.d.ts","sourceRoot":"","sources":["../../../../../src/genai/instrumentations/openai/openAIAgentsTraceProcessor.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,MAAM,IAAI,UAAU,EAErB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,IAAI,IAAI,UAAU,EAClB,QAAQ,EAER,KAAK,IAAI,UAAU,EACnB,gBAAgB,EACjB,MAAM,qBAAqB,CAAC;AAwB7B;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,0BAA2B,YAAW,gBAAgB;IACjE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAU;IAErD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAU;IACnD,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAU;IAEpD,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAC9D,iDAAiD;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAC9D,0CAA0C;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IACtE,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;gBAG5D,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE;QACR,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;KACrC;IAOH,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,SAAS;IAMJ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5C,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDtD,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgDpD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASvD,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,uBAAuB;IAkE/B,OAAO,CAAC,yBAAyB;IA2BjC,OAAO,CAAC,uBAAuB;IAwB/B,OAAO,CAAC,2BAA2B;IAkBnC,OAAO,CAAC,sBAAsB;IAe9B,OAAO,CAAC,oBAAoB;IAkB5B,OAAO,CAAC,iBAAiB;CAS1B"}

package/dist/esm/genai/instrumentations/openai/openAIAgentsTraceProcessor.js

@@ -0,0 +1,313 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Vendored from microsoft/Agent365-nodejs packages/agents-a365-observability-extensions-openai
+// Adapted: removed A365 ObservabilityManager dependency, uses local semconv + utils
+import { context, trace as OtelTrace, diag, } from "@opentelemetry/api";
+import { ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_PROVIDER_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_TOOL_TYPE, ATTR_GEN_AI_TOOL_NAME, GEN_AI_OPERATION_CHAT, GEN_AI_OPERATION_EXECUTE_TOOL, GEN_AI_OPERATION_INVOKE_AGENT, } from "../../index.js";
+import { truncateValue } from "../../utils.js";
+import { GEN_AI_GRAPH_NODE_ID, GEN_AI_GRAPH_NODE_PARENT_ID, GEN_AI_RESPONSE_CONTENT_KEY, GEN_AI_EXECUTION_PAYLOAD_KEY, } from "./semconv.js";
+import * as Utils from "./utils.js";
+/**
+ * OpenTelemetry-based trace processor for the OpenAI Agents SDK.
+ *
+ * Implements the `TracingProcessor` interface from `@openai/agents-core` so it
+ * can be registered via `setTraceProcessors()`. Every OpenAI agent span
+ * (agent invocation, function/tool call, LLM generation, response, handoff,
+ * MCP list-tools) is mapped to an OTel span with GenAI semantic convention
+ * attributes.
+ *
+ * Key behaviors:
+ * - Creates an OTel span on `onSpanStart` and ends it on `onSpanEnd`.
+ * - Maintains parent–child span relationships via trace/span ID maps.
+ * - Guards against unbounded memory with a hard cap of {@link MAX_SPANS_IN_FLIGHT}.
+ * - Content-sensitive attributes (messages, tool args) are only recorded
+ *   when `isContentRecordingEnabled` is true.
+ */
+export class OpenAIAgentsTraceProcessor {
+    static MAX_HANDOFFS_IN_FLIGHT = 1_000;
+    static MAX_SPANS_IN_FLIGHT = 10_000;
+    tracer;
+    suppressInvokeAgentInput;
+    isContentRecordingEnabled;
+    /** Root spans keyed by trace ID. */
+    rootSpans = new Map();
+    /** Active OTel spans keyed by OpenAI span ID. */
+    otelSpans = new Map();
+    /** Context tokens for span activation. */
+    tokens = new Map();
+    /** Reverse handoff map: `${toAgent}:${traceId}` → fromAgent */
+    reverseHandoffsDict = new Map();
+    /** Span names for lookup (OTel Span doesn't expose name). */
+    spanNames = new Map();
+    constructor(tracer, options) {
+        this.tracer = tracer;
+        this.suppressInvokeAgentInput = options?.suppressInvokeAgentInput ?? false;
+        this.isContentRecordingEnabled = options?.isContentRecordingEnabled ?? false;
+    }
+    isContentKey(key) {
+        return Utils.CONTENT_KEYS.has(key);
+    }
+    getNewKey(spanType, key) {
+        return Utils.KEY_MAPPINGS.get(`${spanType}${key}`) ?? null;
+    }
+    // -- TracingProcessor interface --
+    async start() {
+        // no-op
+    }
+    async onTraceStart(_trace) {
+        // no-op
+    }
+    async onTraceEnd(trace) {
+        const rootSpan = this.rootSpans.get(trace.traceId);
+        if (rootSpan) {
+            this.rootSpans.delete(trace.traceId);
+            rootSpan.end();
+        }
+    }
+    async onSpanStart(span) {
+        const spanId = span.spanId;
+        const parentId = span.parentId;
+        const traceId = span.traceId;
+        const startedAt = span.startedAt;
+        const spanData = span.spanData;
+        if (!startedAt || !spanId || !traceId) {
+            return;
+        }
+        if (this.otelSpans.size >= OpenAIAgentsTraceProcessor.MAX_SPANS_IN_FLIGHT) {
+            diag.warn(`[OpenAIAgentsTraceProcessor] Max spans in flight (${OpenAIAgentsTraceProcessor.MAX_SPANS_IN_FLIGHT}) reached, skipping span`);
+            return;
+        }
+        const startTime = new Date(startedAt).getTime();
+        // Find parent span
+        const parentSpan = parentId ? this.otelSpans.get(parentId) : this.rootSpans.get(traceId);
+        // Create context with parent
+        const parentContext = parentSpan
+            ? OtelTrace.setSpan(context.active(), parentSpan)
+            : context.active();
+        const spanName = Utils.getSpanName(span);
+        // Start OpenTelemetry span
+        const otelSpan = this.tracer.startSpan(spanName, {
+            startTime,
+            attributes: {
+                [ATTR_GEN_AI_OPERATION_NAME]: Utils.getOperationName(spanData),
+                [ATTR_GEN_AI_PROVIDER_NAME]: "openai",
+            },
+        }, parentContext);
+        if (!parentSpan) {
+            this.rootSpans.set(traceId, otelSpan);
+        }
+        this.otelSpans.set(spanId, otelSpan);
+        this.spanNames.set(otelSpan, spanName);
+        const newContext = OtelTrace.setSpan(context.active(), otelSpan);
+        const token = context.with(newContext, () => context.active());
+        this.tokens.set(spanId, token);
+    }
+    async onSpanEnd(span) {
+        const spanId = span.spanId;
+        const traceId = span.traceId;
+        const endedAt = span.endedAt;
+        const spanData = span.spanData;
+        if (!spanId || !traceId) {
+            return;
+        }
+        // Cleanup context token
+        const token = this.tokens.get(spanId);
+        if (token) {
+            this.tokens.delete(spanId);
+        }
+        const otelSpan = this.otelSpans.get(spanId);
+        if (!otelSpan) {
+            return;
+        }
+        this.otelSpans.delete(spanId);
+        this.spanNames.delete(otelSpan);
+        // Clean up root span reference if this is the root
+        const rootSpan = this.rootSpans.get(traceId);
+        if (rootSpan === otelSpan) {
+            this.rootSpans.delete(traceId);
+        }
+        // Update span name
+        otelSpan.updateName(Utils.getSpanName(span));
+        // Process based on span data type
+        if (spanData) {
+            this.processSpanData(otelSpan, spanData, traceId);
+        }
+        // Set end time and status
+        const endTime = endedAt ? new Date(endedAt).getTime() : undefined;
+        const status = Utils.getSpanStatus(span);
+        otelSpan.setStatus(status);
+        if (endTime) {
+            otelSpan.end(endTime);
+        }
+        else {
+            otelSpan.end();
+        }
+    }
+    async forceFlush() {
+        // no-op
+    }
+    async shutdown(_timeout) {
+        this.rootSpans.clear();
+        this.otelSpans.clear();
+        this.tokens.clear();
+        this.reverseHandoffsDict.clear();
+    }
+    // -- Span data processors --
+    processSpanData(otelSpan, data, traceId) {
+        const type = data.type;
+        const contentRecording = this.isContentRecordingEnabled;
+        switch (type) {
+            case "response":
+                this.processResponseSpanData(otelSpan, data, contentRecording);
+                break;
+            case "generation":
+                this.processGenerationSpanData(otelSpan, data, traceId, contentRecording);
+                break;
+            case "function":
+                this.processFunctionSpanData(otelSpan, data, traceId, contentRecording);
+                break;
+            case "mcp_tools":
+                this.processMCPListToolsSpanData(otelSpan, data);
+                break;
+            case "handoff":
+                this.processHandoffSpanData(otelSpan, data, traceId);
+                break;
+            case "agent":
+                this.processAgentSpanData(otelSpan, data, traceId);
+                break;
+        }
+    }
+    processResponseSpanData(otelSpan, data, contentRecording) {
+        const responseData = data;
+        const responseObj = responseData._response || responseData.response;
+        const inputObj = responseData._input || responseData.input;
+        if (responseObj) {
+            const resp = responseObj;
+            if (resp.output && contentRecording) {
+                if (typeof resp.output === "string") {
+                    otelSpan.setAttribute(ATTR_GEN_AI_OUTPUT_MESSAGES, truncateValue(resp.output));
+                }
+                else {
+                    otelSpan.setAttribute(ATTR_GEN_AI_OUTPUT_MESSAGES, truncateValue(Utils.buildOutputMessages(resp.output)));
+                }
+            }
+            // Get attributes but filter out response content key (handled above)
+            const attrs = Utils.getAttributesFromResponse(responseObj);
+            Object.entries(attrs).forEach(([key, value]) => {
+                if (value !== null && value !== undefined && key !== GEN_AI_RESPONSE_CONTENT_KEY) {
+                    otelSpan.setAttribute(key, value);
+                }
+            });
+            const modelName = attrs[ATTR_GEN_AI_REQUEST_MODEL] ?? "";
+            otelSpan.updateName(`${GEN_AI_OPERATION_CHAT} ${modelName}`);
+        }
+        if (inputObj && !this.suppressInvokeAgentInput && contentRecording) {
+            if (typeof inputObj === "string") {
+                try {
+                    const parsed = JSON.parse(inputObj);
+                    if (Array.isArray(parsed)) {
+                        otelSpan.setAttribute(ATTR_GEN_AI_INPUT_MESSAGES, truncateValue(Utils.buildInputMessages(parsed)));
+                        return;
+                    }
+                }
+                catch {
+                    // Fall back to raw string
+                }
+                otelSpan.setAttribute(ATTR_GEN_AI_INPUT_MESSAGES, truncateValue(inputObj));
+            }
+            else if (Array.isArray(inputObj)) {
+                otelSpan.setAttribute(ATTR_GEN_AI_INPUT_MESSAGES, truncateValue(Utils.buildInputMessages(inputObj)));
+            }
+        }
+    }
+    processGenerationSpanData(otelSpan, data, traceId, contentRecording) {
+        const attrs = Utils.getAttributesFromGenerationSpanData(data);
+        Object.entries(attrs).forEach(([key, value]) => {
+            const shouldExcludeKey = key === GEN_AI_EXECUTION_PAYLOAD_KEY;
+            if (value !== null && value !== undefined && !shouldExcludeKey) {
+                const newKey = this.getNewKey(data.type, key);
+                const resolvedKey = newKey || key;
+                if (!this.isContentKey(resolvedKey) || contentRecording) {
+                    otelSpan.setAttribute(resolvedKey, value);
+                }
+            }
+        });
+        this.stampCustomParent(otelSpan, traceId);
+        const operationName = attrs[ATTR_GEN_AI_OPERATION_NAME];
+        const modelName = attrs[ATTR_GEN_AI_REQUEST_MODEL];
+        if (operationName && modelName) {
+            otelSpan.updateName(`${operationName} ${modelName}`);
+        }
+    }
+    processFunctionSpanData(otelSpan, data, traceId, contentRecording) {
+        const functionData = data;
+        const attrs = Utils.getAttributesFromFunctionSpanData(data);
+        Object.entries(attrs).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                const newKey = this.getNewKey(data.type, key);
+                const resolvedKey = newKey || key;
+                if (!this.isContentKey(resolvedKey) || contentRecording) {
+                    otelSpan.setAttribute(resolvedKey, value);
+                }
+            }
+        });
+        otelSpan.setAttribute(ATTR_GEN_AI_TOOL_TYPE, "function");
+        this.stampCustomParent(otelSpan, traceId);
+        otelSpan.updateName(`${GEN_AI_OPERATION_EXECUTE_TOOL} ${functionData.name ?? ""}`);
+        otelSpan.setAttribute(ATTR_GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL);
+    }
+    processMCPListToolsSpanData(otelSpan, data) {
+        const attrs = Utils.getAttributesFromMCPListToolsSpanData(data);
+        Object.entries(attrs).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                const newKey = this.getNewKey(data.type, key);
+                otelSpan.setAttribute(newKey || key, value);
+            }
+        });
+        otelSpan.setAttribute(ATTR_GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL);
+        const serverName = data.server ?? "unknown";
+        otelSpan.updateName(`${GEN_AI_OPERATION_EXECUTE_TOOL} ${serverName}`);
+        if (serverName) {
+            otelSpan.setAttribute(ATTR_GEN_AI_TOOL_NAME, serverName);
+        }
+        otelSpan.setAttribute(ATTR_GEN_AI_TOOL_TYPE, "extension");
+    }
+    processHandoffSpanData(_otelSpan, data, traceId) {
+        const handoffData = data;
+        if (handoffData.to_agent && handoffData.from_agent) {
+            const key = `${handoffData.to_agent}:${traceId}`;
+            this.reverseHandoffsDict.set(key, handoffData.from_agent);
+            while (this.reverseHandoffsDict.size > OpenAIAgentsTraceProcessor.MAX_HANDOFFS_IN_FLIGHT) {
+                const firstKey = this.reverseHandoffsDict.keys().next().value;
+                if (firstKey) {
+                    this.reverseHandoffsDict.delete(firstKey);
+                }
+            }
+        }
+    }
+    processAgentSpanData(otelSpan, data, traceId) {
+        const agentData = data;
+        if (agentData.name) {
+            otelSpan.setAttribute(GEN_AI_GRAPH_NODE_ID, agentData.name);
+            otelSpan.setAttribute(ATTR_GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_INVOKE_AGENT);
+            // Lookup parent node from handoff
+            const key = `${agentData.name}:${traceId}`;
+            const parentNode = this.reverseHandoffsDict.get(key);
+            if (parentNode) {
+                this.reverseHandoffsDict.delete(key);
+                otelSpan.setAttribute(GEN_AI_GRAPH_NODE_PARENT_ID, parentNode);
+            }
+            otelSpan.updateName(`${GEN_AI_OPERATION_INVOKE_AGENT} ${agentData.name}`);
+        }
+    }
+    stampCustomParent(otelSpan, traceId) {
+        const root = this.rootSpans.get(traceId);
+        if (!root) {
+            return;
+        }
+        const spanContext = root.spanContext();
+        const pidHex = `0x${spanContext.spanId}`;
+        otelSpan.setAttribute("custom.parent.span.id", pidHex);
+    }
+}
+//# sourceMappingURL=openAIAgentsTraceProcessor.js.map