@traceloop/instrumentation-anthropic 0.9.2 → 0.11.0

package/dist/index.js

@@ -5,7 +5,7 @@ var api = require('@opentelemetry/api');
 var instrumentation = require('@opentelemetry/instrumentation');
 var aiSemanticConventions = require('@traceloop/ai-semantic-conventions');
 
-var version = "0.9.2";
+var version = "0.11.0";
 
 class AnthropicInstrumentation extends instrumentation.InstrumentationBase {
     constructor(config = {}) {

package/dist/index.mjs

@@ -0,0 +1,303 @@
+import { __asyncGenerator, __asyncValues, __await } from 'tslib';
+import { trace, context, SpanKind, SpanStatusCode } from '@opentelemetry/api';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, safeExecuteInTheMiddle } from '@opentelemetry/instrumentation';
+import { SpanAttributes, CONTEXT_KEY_ALLOW_TRACE_CONTENT } from '@traceloop/ai-semantic-conventions';
+
+var version = "0.11.0";
+
+class AnthropicInstrumentation extends InstrumentationBase {
+    constructor(config = {}) {
+        super("@traceloop/instrumentation-anthropic", version, config);
+    }
+    setConfig(config = {}) {
+        super.setConfig(config);
+    }
+    manuallyInstrument(module) {
+        this._diag.debug(`Patching @anthropic-ai/sdk manually`);
+        this._wrap(module.Anthropic.Completions.prototype, "create", this.patchAnthropic("completion"));
+        this._wrap(module.Anthropic.Messages.prototype, "create", this.patchAnthropic("chat"));
+    }
+    init() {
+        const module = new InstrumentationNodeModuleDefinition("@anthropic-ai/sdk", [">=0.9.1"], this.patch.bind(this), this.unpatch.bind(this));
+        return module;
+    }
+    patch(moduleExports, moduleVersion) {
+        this._diag.debug(`Patching  @anthropic-ai/sdk@${moduleVersion}`);
+        this._wrap(moduleExports.Anthropic.Completions.prototype, "create", this.patchAnthropic("completion"));
+        this._wrap(moduleExports.Anthropic.Messages.prototype, "create", this.patchAnthropic("chat"));
+        return moduleExports;
+    }
+    unpatch(moduleExports, moduleVersion) {
+        this._diag.debug(`Unpatching @azure/openai@${moduleVersion}`);
+        this._unwrap(moduleExports.Anthropic.Completions.prototype, "create");
+        this._unwrap(moduleExports.Anthropic.Messages.prototype, "create");
+    }
+    patchAnthropic(type) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const plugin = this;
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        return (original) => {
+            return function method(...args) {
+                const span = type === "chat"
+                    ? plugin.startSpan({
+                        type,
+                        params: args[0],
+                    })
+                    : plugin.startSpan({
+                        type,
+                        params: args[0],
+                    });
+                const execContext = trace.setSpan(context.active(), span);
+                const execPromise = safeExecuteInTheMiddle(() => {
+                    return context.with(execContext, () => {
+                        var _a;
+                        if ((_a = args === null || args === void 0 ? void 0 : args[0]) === null || _a === void 0 ? void 0 : _a.extraAttributes) {
+                            delete args[0].extraAttributes;
+                        }
+                        return original.apply(this, args);
+                    });
+                }, (e) => {
+                    if (e) {
+                        plugin._diag.error("Error in Anthropic instrumentation", e);
+                    }
+                });
+                if (args[0].stream &&
+                    type === "completion" // For some reason, this causes an exception with chat, so disabled for now
+                ) {
+                    return context.bind(execContext, plugin._streamingWrapPromise({
+                        span,
+                        type,
+                        promise: execPromise,
+                    }));
+                }
+                const wrappedPromise = plugin._wrapPromise(type, span, execPromise);
+                return context.bind(execContext, wrappedPromise);
+            };
+        };
+    }
+    startSpan({ type, params, }) {
+        var _a, _b;
+        const attributes = {
+            [SpanAttributes.LLM_SYSTEM]: "Anthropic",
+            [SpanAttributes.LLM_REQUEST_TYPE]: type,
+        };
+        try {
+            attributes[SpanAttributes.LLM_REQUEST_MODEL] = params.model;
+            attributes[SpanAttributes.LLM_REQUEST_TEMPERATURE] = params.temperature;
+            attributes[SpanAttributes.LLM_REQUEST_TOP_P] = params.top_p;
+            attributes[SpanAttributes.LLM_TOP_K] = params.top_k;
+            if (type === "completion") {
+                attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] =
+                    params.max_tokens_to_sample;
+            }
+            else {
+                attributes[SpanAttributes.LLM_REQUEST_MAX_TOKENS] = params.max_tokens;
+            }
+            if (params.extraAttributes !== undefined &&
+                typeof params.extraAttributes === "object") {
+                Object.keys(params.extraAttributes).forEach((key) => {
+                    attributes[key] = params.extraAttributes[key];
+                });
+            }
+            if (this._shouldSendPrompts()) {
+                if (type === "chat") {
+                    params.messages.forEach((message, index) => {
+                        attributes[`${SpanAttributes.LLM_PROMPTS}.${index}.role`] =
+                            message.role;
+                        if (typeof message.content === "string") {
+                            attributes[`${SpanAttributes.LLM_PROMPTS}.${index}.content`] =
+                                message.content || "";
+                        }
+                        else {
+                            attributes[`${SpanAttributes.LLM_PROMPTS}.${index}.content`] =
+                                JSON.stringify(message.content);
+                        }
+                    });
+                }
+                else {
+                    attributes[`${SpanAttributes.LLM_PROMPTS}.0.role`] = "user";
+                    attributes[`${SpanAttributes.LLM_PROMPTS}.0.content`] = params.prompt;
+                }
+            }
+        }
+        catch (e) {
+            this._diag.debug(e);
+            (_b = (_a = this._config).exceptionLogger) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        }
+        return this.tracer.startSpan(`anthropic.${type}`, {
+            kind: SpanKind.CLIENT,
+            attributes,
+        });
+    }
+    _streamingWrapPromise({ span, type, promise, }) {
+        var _a, _b, _c, _d;
+        return __asyncGenerator(this, arguments, function* _streamingWrapPromise_1() {
+            var _e, e_1, _f, _g, _h, e_2, _j, _k;
+            if (type === "chat") {
+                const result = {
+                    id: "0",
+                    type: "message",
+                    model: "",
+                    role: "assistant",
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 },
+                    content: [],
+                };
+                try {
+                    for (var _l = true, _m = __asyncValues(yield __await(promise)), _o; _o = yield __await(_m.next()), _e = _o.done, !_e; _l = true) {
+                        _g = _o.value;
+                        _l = false;
+                        const chunk = _g;
+                        yield yield __await(chunk);
+                        try {
+                            switch (chunk.type) {
+                                case "content_block_start":
+                                    if (result.content.length <= chunk.index) {
+                                        result.content.push(chunk.content_block);
+                                    }
+                                    break;
+                                case "content_block_delta":
+                                    if (chunk.index < result.content.length) {
+                                        result.content[chunk.index] = {
+                                            type: "text",
+                                            text: result.content[chunk.index].text + chunk.delta.text,
+                                        };
+                                    }
+                            }
+                        }
+                        catch (e) {
+                            this._diag.debug(e);
+                            (_b = (_a = this._config).exceptionLogger) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_l && !_e && (_f = _m.return)) yield __await(_f.call(_m));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                this._endSpan({ span, type, result });
+            }
+            else {
+                const result = {
+                    id: "0",
+                    type: "completion",
+                    model: "",
+                    completion: "",
+                    stop_reason: null,
+                };
+                try {
+                    for (var _p = true, _q = __asyncValues(yield __await(promise)), _r; _r = yield __await(_q.next()), _h = _r.done, !_h; _p = true) {
+                        _k = _r.value;
+                        _p = false;
+                        const chunk = _k;
+                        yield yield __await(chunk);
+                        try {
+                            result.id = chunk.id;
+                            result.model = chunk.model;
+                            if (chunk.stop_reason) {
+                                result.stop_reason = chunk.stop_reason;
+                            }
+                            if (chunk.model) {
+                                result.model = chunk.model;
+                            }
+                            if (chunk.completion) {
+                                result.completion += chunk.completion;
+                            }
+                        }
+                        catch (e) {
+                            this._diag.debug(e);
+                            (_d = (_c = this._config).exceptionLogger) === null || _d === void 0 ? void 0 : _d.call(_c, e);
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_p && !_h && (_j = _q.return)) yield __await(_j.call(_q));
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                this._endSpan({ span, type, result });
+            }
+        });
+    }
+    _wrapPromise(type, span, promise) {
+        return promise
+            .then((result) => {
+            return new Promise((resolve) => {
+                if (type === "chat") {
+                    this._endSpan({
+                        type,
+                        span,
+                        result: result,
+                    });
+                }
+                else {
+                    this._endSpan({
+                        type,
+                        span,
+                        result: result,
+                    });
+                }
+                resolve(result);
+            });
+        })
+            .catch((error) => {
+            return new Promise((_, reject) => {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                span.recordException(error);
+                span.end();
+                reject(error);
+            });
+        });
+    }
+    _endSpan({ span, type, result, }) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            span.setAttribute(SpanAttributes.LLM_RESPONSE_MODEL, result.model);
+            if (type === "chat" && result.usage) {
+                span.setAttribute(SpanAttributes.LLM_USAGE_TOTAL_TOKENS, ((_a = result.usage) === null || _a === void 0 ? void 0 : _a.input_tokens) + ((_b = result.usage) === null || _b === void 0 ? void 0 : _b.output_tokens));
+                span.setAttribute(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, (_c = result.usage) === null || _c === void 0 ? void 0 : _c.output_tokens);
+                span.setAttribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, (_d = result.usage) === null || _d === void 0 ? void 0 : _d.input_tokens);
+            }
+            result.stop_reason &&
+                span.setAttribute(`${SpanAttributes.LLM_COMPLETIONS}.0.finish_reason`, result.stop_reason);
+            if (this._shouldSendPrompts()) {
+                if (type === "chat") {
+                    span.setAttribute(`${SpanAttributes.LLM_COMPLETIONS}.0.role`, "assistant");
+                    span.setAttribute(`${SpanAttributes.LLM_COMPLETIONS}.0.content`, JSON.stringify(result.content));
+                }
+                else {
+                    span.setAttribute(`${SpanAttributes.LLM_COMPLETIONS}.0.role`, "assistant");
+                    span.setAttribute(`${SpanAttributes.LLM_COMPLETIONS}.0.content`, result.completion);
+                }
+            }
+        }
+        catch (e) {
+            this._diag.debug(e);
+            (_f = (_e = this._config).exceptionLogger) === null || _f === void 0 ? void 0 : _f.call(_e, e);
+        }
+        span.end();
+    }
+    _shouldSendPrompts() {
+        const contextShouldSendPrompts = context
+            .active()
+            .getValue(CONTEXT_KEY_ALLOW_TRACE_CONTENT);
+        if (contextShouldSendPrompts !== undefined) {
+            return contextShouldSendPrompts;
+        }
+        return this._config.traceContent !== undefined
+            ? this._config.traceContent
+            : true;
+    }
+}
+
+export { AnthropicInstrumentation };
+//# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traceloop/instrumentation-anthropic",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Anthropic Instrumentaion",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -26,6 +26,7 @@
   },
   "files": [
     "dist/**/*.js",
+    "dist/**/*.mjs",
     "dist/**/*.js.map",
     "dist/**/*.d.ts",
     "doc",
@@ -40,7 +41,7 @@
     "@opentelemetry/core": "^1.25.0",
     "@opentelemetry/instrumentation": "^0.52.0",
     "@opentelemetry/semantic-conventions": "^1.25.0",
-    "@traceloop/ai-semantic-conventions": "^0.9.0",
+    "@traceloop/ai-semantic-conventions": "^0.11.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
@@ -52,5 +53,5 @@
     "ts-mocha": "^10.0.0"
   },
   "homepage": "https://github.com/traceloop/openllmetry-js/tree/main/packages/instrumentation-anthropic",
-  "gitHead": "5019c20e284836be10641e7d2c5692ef8621475d"
+  "gitHead": "77fe2d5853f90f5a9c1f1fedece8e3e8fc702adf"
 }