Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
feat(typescript): add integrations, align semantic conventions, derive version from package.json (#1035)
Aman Agarwalc1aa4cd140a3
diff --git a/docs/latest/sdk/integrations/overview.mdx b/docs/latest/sdk/integrations/overview.mdxindex ca4497f2..36c74863 100644--- a/docs/latest/sdk/integrations/overview.mdx+++ b/docs/latest/sdk/integrations/overview.mdx@@ -373,6 +373,7 @@ Start integrating and monitoring your applications with OpenLIT in just one line><div style={{position: "absolute", top: "12px", right: "12px", display: "flex", gap: "4px"}}><img src="https://cdn.simpleicons.org/python/ffa500" width="16" height="16" alt="Python SDK" title="Python SDK" />+ <img src="https://cdn.simpleicons.org/typescript/ffa500" width="16" height="16" alt="TypeScript SDK" title="TypeScript SDK" /></div></Card>@@ -602,6 +603,22 @@ Start integrating and monitoring your applications with OpenLIT in just one line<img src="https://cdn.simpleicons.org/python/ffa500" width="16" height="16" alt="Python SDK" title="Python SDK" /></div>+ </Card>+ <Card+ title="Replicate"+ href="/latest/sdk/integrations/replicate"+ icon={+ <svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">+ <title>Replicate</title>+ <path d="M12 0C5.373 0 0 5.373 0 12s5.373 12 12 12 12-5.373 12-12S18.627 0 12 0zm0 21.6c-5.301 0-9.6-4.299-9.6-9.6S6.699 2.4 12 2.4s9.6 4.299 9.6 9.6-4.299 9.6-9.6 9.6z" fill="currentColor"/>+ </svg>+ }+ iconType="duotone"+ >+ <div style={{position: "absolute", top: "12px", right: "12px", display: "flex", gap: "4px"}}>+ <img src="https://cdn.simpleicons.org/typescript/ffa500" width="16" height="16" alt="TypeScript SDK" title="TypeScript SDK" />+ </div>+</Card><Cardtitle="Together.ai"@@ -2415,6 +2432,22 @@ Start integrating and monitoring your applications with OpenLIT in just one line<img src="https://cdn.simpleicons.org/python/ffa500" width="16" height="16" alt="Python SDK" title="Python SDK" /> <img src="https://cdn.simpleicons.org/typescript/ffa500" width="16" height="16" alt="TypeScript SDK" title="TypeScript SDK" /></div>+ </Card>+ <Card+ title="Vercel AI SDK"+ href="/latest/sdk/integrations/vercel-ai"+ icon={+ <svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">+ <title>Vercel</title>+ <path d="M24 22.525H0l12-21.05 12 21.05z" fill="currentColor"/>+ </svg>+ }+ iconType="duotone"+ >+ <div style={{position: "absolute", top: "12px", right: "12px", display: "flex", gap: "4px"}}>+ <img src="https://cdn.simpleicons.org/typescript/ffa500" width="16" height="16" alt="TypeScript SDK" title="TypeScript SDK" />+ </div>+</Card><Cardtitle="Browser Use"diff --git a/docs/latest/sdk/integrations/replicate.mdx b/docs/latest/sdk/integrations/replicate.mdxnew file mode 100644index 00000000..bb394797--- /dev/null+++ b/docs/latest/sdk/integrations/replicate.mdx@@ -0,0 +1,49 @@+---+title: 'Monitor Replicate using OpenTelemetry'+sidebarTitle: 'Replicate'+---++import IntegrationMethods from '/snippets/integration-methods.mdx';++OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor AI applications built using the Replicate API. This includes tracking performance, model usage, and how users interact with your application.++Auto-instrumentation means you don't have to set up monitoring manually for different models or providers. By simply adding OpenLIT in your application, all the necessary monitoring configurations are automatically set up.++The integration is compatible with+- Replicate JavaScript/TypeScript SDK client++## Get started++<Steps>+ <Step title="Install OpenLIT">+ Open your command line or terminal and run:+ ```shell+ npm install openlit+ ```+ </Step>+ <IntegrationMethods />+</Steps>++---++<CardGroup cols={3}>+ <Card title="Quickstart: LLM Observability" href="/latest/sdk/quickstart-ai-observability" icon='bolt'>+ Production-ready AI monitoring setup in 2 simple steps with zero code changes+ </Card>+ <Card title="Configuration" href="/latest/sdk/configuration" icon='bolt'>+ Configure the OpenLIT SDK according to you requirements.+ </Card>+ <Card title="Destinations" href="/latest/sdk/destinations/overview" icon='link'>+ Send telemetry to Datadog, Grafana, New Relic, and other observability stacks+ </Card>+</CardGroup>+<Card+ title="Running in Kubernetes? Try the OpenLIT Operator"+ icon={<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">+ <title>Kubernetes</title>+ <path fill="#FFA500" d="M10.204 14.35l.007.01-.999 2.413a5.171 5.171 0 0 1-2.075-2.597l2.578-.437.004.005a.44.44 0 0 1 .484.606zm-.833-2.129a.44.44 0 0 0 .173-.756l.002-.011L7.585 9.7a5.143 5.143 0 0 0-.73 3.255l2.514-.725.002-.009zm1.145-1.98a.44.44 0 0 0 .699-.337l.01-.005.15-2.62a5.144 5.144 0 0 0-3.01 1.442l2.147 1.523.004-.002zm.76 2.75l.723.349.722-.347.18-.78-.5-.623h-.804l-.5.623.179.779zm1.5-3.095a.44.44 0 0 0 .7.336l.008.003 2.134-1.513a5.188 5.188 0 0 0-2.992-1.442l.148 2.615.002.001zm10.876 5.97l-5.773 7.181a1.6 1.6 0 0 1-1.248.594l-9.261.003a1.6 1.6 0 0 1-1.247-.596l-5.776-7.18a1.583 1.583 0 0 1-.307-1.34L2.1 5.573c.108-.47.425-.864.863-1.073L11.305.513a1.606 1.606 0 0 1 1.385 0l8.345 3.985c.438.209.755.604.863 1.073l2.062 8.955c.108.47-.005.963-.308 1.34z"/>+ </svg>}+ href="/latest/operator/overview"+ >+ Automatically inject instrumentation into existing workloads without modifying pod specs, container images, or application code.+</Card>diff --git a/docs/latest/sdk/integrations/vercel-ai.mdx b/docs/latest/sdk/integrations/vercel-ai.mdxnew file mode 100644index 00000000..5631c909--- /dev/null+++ b/docs/latest/sdk/integrations/vercel-ai.mdx@@ -0,0 +1,49 @@+---+title: 'Monitor Vercel AI SDK using OpenTelemetry'+sidebarTitle: 'Vercel AI SDK'+---++import IntegrationMethods from '/snippets/integration-methods.mdx';++OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor AI applications built using the Vercel AI SDK. This includes tracking performance, token usage, and how users interact with your application.++Auto-instrumentation means you don't have to set up monitoring manually for different providers or models. By simply adding OpenLIT in your application, all the necessary monitoring configurations are automatically set up.++The integration is compatible with+- Vercel AI SDK (`ai` package)++## Get started++<Steps>+ <Step title="Install OpenLIT">+ Open your command line or terminal and run:+ ```shell+ npm install openlit+ ```+ </Step>+ <IntegrationMethods />+</Steps>++---++<CardGroup cols={3}>+ <Card title="Quickstart: LLM Observability" href="/latest/sdk/quickstart-ai-observability" icon='bolt'>+ Production-ready AI monitoring setup in 2 simple steps with zero code changes+ </Card>+ <Card title="Configuration" href="/latest/sdk/configuration" icon='bolt'>+ Configure the OpenLIT SDK according to you requirements.+ </Card>+ <Card title="Destinations" href="/latest/sdk/destinations/overview" icon='link'>+ Send telemetry to Datadog, Grafana, New Relic, and other observability stacks+ </Card>+</CardGroup>+<Card+ title="Running in Kubernetes? Try the OpenLIT Operator"+ icon={<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">+ <title>Kubernetes</title>+ <path fill="#FFA500" d="M10.204 14.35l.007.01-.999 2.413a5.171 5.171 0 0 1-2.075-2.597l2.578-.437.004.005a.44.44 0 0 1 .484.606zm-.833-2.129a.44.44 0 0 0 .173-.756l.002-.011L7.585 9.7a5.143 5.143 0 0 0-.73 3.255l2.514-.725.002-.009zm1.145-1.98a.44.44 0 0 0 .699-.337l.01-.005.15-2.62a5.144 5.144 0 0 0-3.01 1.442l2.147 1.523.004-.002zm.76 2.75l.723.349.722-.347.18-.78-.5-.623h-.804l-.5.623.179.779zm1.5-3.095a.44.44 0 0 0 .7.336l.008.003 2.134-1.513a5.188 5.188 0 0 0-2.992-1.442l.148 2.615.002.001zm10.876 5.97l-5.773 7.181a1.6 1.6 0 0 1-1.248.594l-9.261.003a1.6 1.6 0 0 1-1.247-.596l-5.776-7.18a1.583 1.583 0 0 1-.307-1.34L2.1 5.573c.108-.47.425-.864.863-1.073L11.305.513a1.606 1.606 0 0 1 1.385 0l8.345 3.985c.438.209.755.604.863 1.073l2.062 8.955c.108.47-.005.963-.308 1.34z"/>+ </svg>}+ href="/latest/operator/overview"+ >+ Automatically inject instrumentation into existing workloads without modifying pod specs, container images, or application code.+</Card>diff --git a/sdk/typescript/README.md b/sdk/typescript/README.mdindex b07bf50a..c60cff1e 100644--- a/sdk/typescript/README.md+++ b/sdk/typescript/README.md@@ -24,7 +24,7 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi## ⚡ Features-- 🔎 **Auto Instrumentation**: Works with 8 LLM providers with just one line of code.+- 🔎 **Auto Instrumentation**: Works with 12+ LLM providers, vector databases, and AI frameworks with just one line of code.- 🔭 **OpenTelemetry-Native Observability SDKs**: Vendor-neutral SDKs that can send traces and metrics to your existing observability tool like Prometheus and Jaeger.- 💲 **Cost Tracking for Custom and Fine-Tuned Models**: Pass custom pricing files for accurate budgeting of custom and fine-tuned models.- 🚀 **Support for OpenLIT Features**: Includes support for prompt management and secrets management features available in OpenLIT.@@ -42,8 +42,24 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi| [✅ Google AI Studio](https://docs.openlit.io/latest/integrations/google-ai-studio) || [✅ Together AI](https://docs.openlit.io/latest/integrations/together) || [✅ Ollama](https://docs.openlit.io/latest/integrations/ollama) |+| [✅ AWS Bedrock](https://docs.openlit.io/latest/integrations/bedrock) |+| [✅ Hugging Face](https://docs.openlit.io/latest/integrations/huggingface) |+| [✅ Replicate](https://docs.openlit.io/latest/integrations/replicate) || [✅ Azure OpenAI](https://docs.openlit.io/latest/integrations/azure-openai) *(via OpenAI SDK)* |+| Vector Databases |+| ------------------------------------------------------------------------------------------- |+| [✅ Chroma](https://docs.openlit.io/latest/integrations/chromadb) |+| [✅ Pinecone](https://docs.openlit.io/latest/integrations/pinecone) |+| [✅ Qdrant](https://docs.openlit.io/latest/integrations/qdrant) |+| [✅ Milvus](https://docs.openlit.io/latest/integrations/milvus) |++| Frameworks |+| ------------------------------------------------------------------------------------------- |+| [✅ LangChain](https://docs.openlit.io/latest/integrations/langchain) |+| [✅ LlamaIndex](https://docs.openlit.io/latest/integrations/llama-index) |+| [✅ Vercel AI SDK](https://docs.openlit.io/latest/integrations/vercel-ai) |+## Supported Destinations- [✅ OpenTelemetry Collector](https://docs.openlit.io/latest/connections/otelcol)diff --git a/sdk/typescript/package-lock.json b/sdk/typescript/package-lock.jsonindex 826f077c..2e2b407f 100644--- a/sdk/typescript/package-lock.json+++ b/sdk/typescript/package-lock.json@@ -1,12 +1,12 @@{"name": "openlit",- "version": "1.9.1",+ "version": "1.10.0","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "openlit",- "version": "1.9.1",+ "version": "1.10.0","license": "ISC","dependencies": {"@anthropic-ai/sdk": "^0.25.0",diff --git a/sdk/typescript/package.json b/sdk/typescript/package.jsonindex f7d6c327..fc42dfe3 100644--- a/sdk/typescript/package.json+++ b/sdk/typescript/package.json@@ -1,6 +1,6 @@{"name": "openlit",- "version": "1.9.1",+ "version": "1.10.0","homepage": "https://github.com/openlit/openlit#readme","bugs": {"url": "https://github.com/openlit/openlit/issues",diff --git a/sdk/typescript/src/constant.ts b/sdk/typescript/src/constant.tsindex fe977c99..1891f27e 100644--- a/sdk/typescript/src/constant.ts+++ b/sdk/typescript/src/constant.ts@@ -1,7 +1,8 @@+import pkg from '../package.json';+export const SDK_NAME = 'openlit';-export const SDK_VERSION = '1.9.1';+export const SDK_VERSION = pkg.version;export const DEFAULT_ENVIRONMENT = 'default';export const DEFAULT_APPLICATION_NAME = 'default';export const INSTRUMENTATION_PREFIX = '@openlit';-export const TELEMETRY_SDK_NAME = 'opentelemetry';export const OPENLIT_URL = 'http://127.0.0.1:3000';diff --git a/sdk/typescript/src/instrumentation/__tests__/chroma-trace-comparison.test.ts b/sdk/typescript/src/instrumentation/__tests__/chroma-trace-comparison.test.tsnew file mode 100644index 00000000..ff065429--- /dev/null+++ b/sdk/typescript/src/instrumentation/__tests__/chroma-trace-comparison.test.ts@@ -0,0 +1,296 @@+/**+ * Cross-Language Trace Comparison Tests for ChromaDB Integration+ *+ * Verifies that TypeScript SDK generates traces consistent with the Python SDK+ * for ChromaDB Collection operations.+ *+ * Python SDK reference: sdk/python/src/openlit/instrumentation/chroma/utils.py+ *+ * Key alignment:+ * - db.system.name = 'chroma'+ * - db.operation.name: INSERT (add), QUERY (query), GET (get), DELETE, PEEK, UPDATE, UPSERT+ * - db.collection.name+ * - server.address, server.port (default localhost:8000)+ * - db.vector.query.top_k for query+ * - db.filter for where-clause filtering+ * - db.query.summary+ */++import ChromaWrapper from '../chroma/wrapper';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';++jest.mock('../../config');+jest.mock('../../helpers');++describe('ChromaDB Cross-Language Trace Comparison', () => {+ let mockSpan: any;+ let mockTracer: any;++ beforeEach(() => {+ mockSpan = {+ setAttribute: jest.fn(),+ addEvent: jest.fn(),+ end: jest.fn(),+ setStatus: jest.fn(),+ };++ mockTracer = {+ startSpan: jest.fn().mockReturnValue(mockSpan),+ };++ (OpenlitConfig as any).environment = 'openlit-testing';+ (OpenlitConfig as any).applicationName = 'openlit-test';+ (OpenlitConfig as any).traceContent = true;+ (OpenLitHelper as any).handleException = jest.fn();+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ // ── Helper: invoke wrapper ────────────────────────────────────────────────++ async function invokeWrapped(+ method: string,+ dbOperation: string,+ collectionName: string,+ params: any,+ returnValue: any = {}+ ) {+ const patchFn = ChromaWrapper._patchCollectionMethod(mockTracer, dbOperation);+ const originalMethod = jest.fn().mockResolvedValue(returnValue);+ const fakeCollectionInstance = { name: collectionName };+ const wrapped = patchFn(originalMethod);+ await wrapped.call(fakeCollectionInstance, params);+ }++ // ── Common DB attributes ──────────────────────────────────────────────────++ it('should set db.system.name = "chroma" matching Python DB_SYSTEM_CHROMA', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'test_col', {+ ids: ['id1'],+ embeddings: [[0.1, 0.2]],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_SYSTEM_NAME,+ 'chroma'+ );+ });++ it('should set server.address = localhost and server.port = 8000 (Python defaults)', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'test_col', {+ ids: ['id1'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_ADDRESS, 'localhost');+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_PORT, 8000);+ });++ it('should set db.collection.name from collection instance', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'my_collection', {+ ids: ['id1'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_COLLECTION_NAME,+ 'my_collection'+ );+ });++ // ── add → INSERT ──────────────────────────────────────────────────────────++ describe('add() → INSERT (matches Python DB_OPERATION_INSERT)', () => {+ it('should set db.operation.name = "INSERT"', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'col', {+ ids: ['id1', 'id2'],+ embeddings: [[0.1], [0.2]],+ documents: ['doc1', 'doc2'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'INSERT'+ );+ });++ it('should set db.vector.count = number of ids', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'col', {+ ids: ['id1', 'id2', 'id3'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_COUNT, 3);+ });++ it('should set db.documents_count when documents provided', async () => {+ await invokeWrapped('add', SemanticConvention.DB_OPERATION_INSERT, 'col', {+ ids: ['id1'],+ documents: ['doc1'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_DOCUMENTS_COUNT, 1);+ });+ });++ // ── query → QUERY ─────────────────────────────────────────────────────────++ describe('query() → QUERY (vector similarity search)', () => {+ it('should set db.operation.name = "QUERY"', async () => {+ await invokeWrapped('query', SemanticConvention.DB_OPERATION_QUERY, 'col', {+ queryEmbeddings: [[0.1, 0.2]],+ nResults: 5,+ }, { ids: [['id1', 'id2']] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'QUERY'+ );+ });++ it('should set db.vector.query.top_k from nResults', async () => {+ await invokeWrapped('query', SemanticConvention.DB_OPERATION_QUERY, 'col', {+ queryEmbeddings: [[0.1]],+ nResults: 10,+ }, { ids: [['id1']] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_QUERY_TOP_K, 10);+ });++ it('should set db.filter when where clause provided (matching Python DB_FILTER)', async () => {+ const where = { source: 'test' };+ await invokeWrapped('query', SemanticConvention.DB_OPERATION_QUERY, 'col', {+ queryEmbeddings: [[0.1]],+ nResults: 5,+ where,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ JSON.stringify(where)+ );+ });++ it('should set db.n_results to number of matched results', async () => {+ await invokeWrapped('query', SemanticConvention.DB_OPERATION_QUERY, 'col', {+ queryEmbeddings: [[0.1]],+ nResults: 5,+ }, { ids: [['r1', 'r2', 'r3']] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_N_RESULTS, 3);+ });+ });++ // ── get → GET ────────────────────────────────────────────────────────────++ describe('get() → GET (retrieve by IDs)', () => {+ it('should set db.operation.name = "GET"', async () => {+ await invokeWrapped('get', SemanticConvention.DB_OPERATION_GET, 'col', {+ ids: ['id1', 'id2'],+ }, { ids: ['id1', 'id2'] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'GET'+ );+ });++ it('should set db.ids_count from ids array length', async () => {+ await invokeWrapped('get', SemanticConvention.DB_OPERATION_GET, 'col', {+ ids: ['id1', 'id2'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_ID_COUNT, 2);+ });+ });++ // ── delete → DELETE ───────────────────────────────────────────────────────++ describe('delete() → DELETE', () => {+ it('should set db.operation.name = "DELETE"', async () => {+ await invokeWrapped('delete', SemanticConvention.DB_OPERATION_DELETE, 'col', {+ ids: ['id1'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'DELETE'+ );+ });++ it('should set db.filter when where clause provided', async () => {+ const where = { category: 'old' };+ await invokeWrapped('delete', SemanticConvention.DB_OPERATION_DELETE, 'col', {+ where,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ JSON.stringify(where)+ );+ });+ });++ // ── peek → PEEK ───────────────────────────────────────────────────────────++ describe('peek() → PEEK', () => {+ it('should set db.operation.name = "PEEK"', async () => {+ await invokeWrapped('peek', SemanticConvention.DB_OPERATION_PEEK, 'col', 5, {+ ids: ['id1', 'id2', 'id3', 'id4', 'id5'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'PEEK'+ );+ });+ });++ // ── upsert → UPSERT ───────────────────────────────────────────────────────++ describe('upsert() → UPSERT', () => {+ it('should set db.operation.name = "UPSERT" and db.vector.count', async () => {+ await invokeWrapped('upsert', SemanticConvention.DB_OPERATION_UPSERT, 'col', {+ ids: ['id1', 'id2'],+ embeddings: [[0.1], [0.2]],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'UPSERT'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_COUNT, 2);+ });+ });++ // ── update → UPDATE ───────────────────────────────────────────────────────++ describe('update() → UPDATE', () => {+ it('should set db.operation.name = "UPDATE"', async () => {+ await invokeWrapped('update', SemanticConvention.DB_OPERATION_UPDATE, 'col', {+ ids: ['id1'],+ documents: ['new content'],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'UPDATE'+ );+ });+ });++ // ── Error handling ────────────────────────────────────────────────────────++ it('should call handleException on error', async () => {+ const patchFn = ChromaWrapper._patchCollectionMethod(mockTracer, SemanticConvention.DB_OPERATION_QUERY);+ const error = new Error('Collection not found');+ const originalMethod = jest.fn().mockRejectedValue(error);+ const fakeInstance = { name: 'missing_col' };+ const wrapped = patchFn(originalMethod);++ await expect(wrapped.call(fakeInstance, {})).rejects.toThrow('Collection not found');+ expect(OpenLitHelper.handleException).toHaveBeenCalledWith(mockSpan, error);+ expect(mockSpan.end).toHaveBeenCalled();+ });+});diff --git a/sdk/typescript/src/instrumentation/__tests__/huggingface-trace-comparison.test.ts b/sdk/typescript/src/instrumentation/__tests__/huggingface-trace-comparison.test.tsnew file mode 100644index 00000000..7223c5fb--- /dev/null+++ b/sdk/typescript/src/instrumentation/__tests__/huggingface-trace-comparison.test.ts@@ -0,0 +1,301 @@+/**+ * Cross-Language Trace Comparison Tests for HuggingFace Inference Integration+ *+ * Verifies that the TypeScript SDK generates traces consistent with the Python SDK+ * for HuggingFace Inference API chatCompletion and textGeneration.+ */++import HuggingFaceWrapper from '../huggingface/wrapper';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import BaseWrapper from '../base-wrapper';+import SemanticConvention from '../../semantic-convention';++jest.mock('../../config');+jest.mock('../../helpers');+jest.mock('../base-wrapper');++describe('HuggingFace Cross-Language Trace Comparison', () => {+ let mockSpan: any;+ let mockTracer: any;++ beforeEach(() => {+ mockSpan = {+ setAttribute: jest.fn(),+ addEvent: jest.fn(),+ end: jest.fn(),+ setStatus: jest.fn(),+ };++ mockTracer = {+ startSpan: jest.fn().mockReturnValue(mockSpan),+ };++ (OpenlitConfig as any).environment = 'openlit-testing';+ (OpenlitConfig as any).applicationName = 'openlit-test';+ (OpenlitConfig as any).traceContent = true;+ (OpenlitConfig as any).pricing_json = {};+ (OpenlitConfig as any).updatePricingJson = jest.fn().mockResolvedValue({});++ (OpenLitHelper as any).getChatModelCost = jest.fn().mockReturnValue(0.0005);+ (OpenLitHelper as any).generalTokens = jest.fn().mockReturnValue(8);+ (OpenLitHelper as any).buildInputMessages = jest.fn().mockReturnValue('[]');+ (OpenLitHelper as any).buildOutputMessages = jest.fn().mockReturnValue('[]');+ (OpenLitHelper as any).handleException = jest.fn();+ (OpenLitHelper as any).createStreamProxy = jest.fn().mockImplementation((stream, _gen) => stream);++ (BaseWrapper as any).recordMetrics = jest.fn();+ (BaseWrapper as any).setBaseSpanAttributes = jest.fn().mockImplementation((span: any, attrs: any) => {+ span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME, attrs.aiSystem);+ span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, attrs.genAIEndpoint);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, attrs.model);+ if (attrs.cost !== undefined) span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, attrs.cost);+ if (attrs.serverAddress) span.setAttribute(SemanticConvention.SERVER_ADDRESS, attrs.serverAddress);+ if (attrs.serverPort !== undefined) span.setAttribute(SemanticConvention.SERVER_PORT, attrs.serverPort);+ span.setAttribute(SemanticConvention.GEN_AI_SDK_VERSION, '1.9.0');+ });+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ // ── Chat Completion ───────────────────────────────────────────────────────++ describe('Chat Completion', () => {+ const mockArgs = [+ {+ model: 'meta-llama/Meta-Llama-3-8B-Instruct',+ messages: [{ role: 'user', content: 'What is LLM Observability?' }],+ max_tokens: 100,+ temperature: 0.7,+ stream: false,+ },+ ];++ const mockResponse = {+ id: 'hf-chat-123',+ created: Date.now(),+ model: 'meta-llama/Meta-Llama-3-8B-Instruct',+ choices: [+ {+ index: 0,+ finish_reason: 'stop',+ message: { role: 'assistant', content: 'LLM Observability is...' },+ },+ ],+ usage: { prompt_tokens: 12, completion_tokens: 25, total_tokens: 37 },+ };++ it('should set gen_ai.system = "huggingface" matching Python GEN_AI_SYSTEM_HUGGING_FACE', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ 'huggingface'+ );+ });++ it('should set gen_ai.operation.name = "chat" matching Python', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OPERATION,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT+ );+ });++ it('should set token usage attributes matching Python SDK', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, 12);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, 25);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, 37);+ });++ it('should set server.address and server.port matching Python', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.SERVER_ADDRESS,+ 'api-inference.huggingface.co'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_PORT, 443);+ });++ it('should set request params: temperature, max_tokens, is_stream', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, 0.7);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, 100);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, false);+ });++ it('should set finish_reason and output_type', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,+ ['stop']+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OUTPUT_TYPE,+ SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT+ );+ });++ it('should call recordMetrics after span ends', async () => {+ await HuggingFaceWrapper._chatCompletion({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.end).toHaveBeenCalled();+ expect(BaseWrapper.recordMetrics).toHaveBeenCalled();+ });+ });++ // ── Streaming ─────────────────────────────────────────────────────────────++ describe('Streaming Chat Completion', () => {+ it('should set is_stream=true and accumulate content across chunks', async () => {+ const mockArgs = [+ {+ model: 'meta-llama/Meta-Llama-3-8B-Instruct',+ messages: [{ role: 'user', content: 'Hello' }],+ stream: true,+ },+ ];++ async function* mockStream() {+ yield {+ id: 'hf-stream-1',+ created: Date.now(),+ model: 'meta-llama/Meta-Llama-3-8B-Instruct',+ choices: [{ delta: { content: 'Hello' } }],+ };+ yield {+ id: 'hf-stream-1',+ created: Date.now(),+ model: 'meta-llama/Meta-Llama-3-8B-Instruct',+ choices: [{ delta: { content: ' world' }, finish_reason: 'stop' }],+ };+ }++ const generator = HuggingFaceWrapper._chatCompletionGenerator({+ args: mockArgs,+ genAIEndpoint: 'huggingface.chat.completions',+ response: mockStream(),+ span: mockSpan,+ });++ for await (const _ of generator) { /* consume */ }++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, true);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ 'huggingface'+ );+ expect(mockSpan.end).toHaveBeenCalled();+ });+ });++ // ── Text Generation ───────────────────────────────────────────────────────++ describe('Text Generation', () => {+ it('should set text_completion operation and correct attributes', async () => {+ const mockArgs = [+ {+ model: 'gpt2',+ inputs: 'The meaning of life is',+ parameters: { max_new_tokens: 50, temperature: 0.9 },+ },+ ];++ const mockResponse = { generated_text: 'The meaning of life is 42.' };++ await HuggingFaceWrapper._textGeneration({+ args: mockArgs,+ genAIEndpoint: 'huggingface.text.generation',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OPERATION,+ SemanticConvention.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ 'huggingface'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, 50);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, 0.9);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, false);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OUTPUT_TYPE,+ SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT+ );+ expect(mockSpan.end).toHaveBeenCalled();+ });++ it('should capture prompt and completion content when traceContent=true', async () => {+ const mockArgs = [+ {+ model: 'gpt2',+ inputs: 'The meaning of life is',+ parameters: {},+ },+ ];+ const mockResponse = { generated_text: '42.' };++ await HuggingFaceWrapper._textGeneration({+ args: mockArgs,+ genAIEndpoint: 'huggingface.text.generation',+ response: mockResponse,+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,+ 'The meaning of life is'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,+ '42.'+ );+ });+ });+});diff --git a/sdk/typescript/src/instrumentation/__tests__/milvus-trace-comparison.test.ts b/sdk/typescript/src/instrumentation/__tests__/milvus-trace-comparison.test.tsnew file mode 100644index 00000000..eb857150--- /dev/null+++ b/sdk/typescript/src/instrumentation/__tests__/milvus-trace-comparison.test.ts@@ -0,0 +1,282 @@+/**+ * Cross-Language Trace Comparison Tests for Milvus Integration+ *+ * Verifies TypeScript SDK trace attributes match Python SDK.+ *+ * Python SDK reference: sdk/python/src/openlit/instrumentation/milvus/milvus.py+ *+ * Key alignment:+ * - db.system.name = 'milvus'+ * - db.operation.name: SEARCH, INSERT, UPSERT, DELETE, QUERY+ * - server.address, server.port (default localhost:19530)+ * - db.vector.query.top_k for search+ * - db.filter for expr/filter params+ * - db.vector.count for insert/upsert+ * - db.query.summary+ */++import MilvusWrapper from '../milvus/wrapper';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';++jest.mock('../../config');+jest.mock('../../helpers');++describe('Milvus Cross-Language Trace Comparison', () => {+ let mockSpan: any;+ let mockTracer: any;++ beforeEach(() => {+ mockSpan = {+ setAttribute: jest.fn(),+ addEvent: jest.fn(),+ end: jest.fn(),+ setStatus: jest.fn(),+ };++ mockTracer = {+ startSpan: jest.fn().mockReturnValue(mockSpan),+ };++ (OpenlitConfig as any).environment = 'openlit-testing';+ (OpenlitConfig as any).applicationName = 'openlit-test';+ (OpenlitConfig as any).traceContent = true;+ (OpenLitHelper as any).handleException = jest.fn();+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ // ── Common attributes ────────────────────────────────────────────────────++ it('should set db.system.name = "milvus" matching Python DB_SYSTEM_MILVUS', async () => {+ const patchFn = MilvusWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ results: [] });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, { collection_name: 'test', vectors: [[0.1]], topk: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_SYSTEM_NAME, 'milvus');+ });++ it('should set server.address = localhost and server.port = 19530', async () => {+ const patchFn = MilvusWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ results: [] });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, { collection_name: 'test', vectors: [[0.1]], topk: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_ADDRESS, 'localhost');+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_PORT, 19530);+ });++ // ── search → SEARCH ───────────────────────────────────────────────────────++ describe('search() → SEARCH', () => {+ async function runSearch(params: any, returnValue: any = { results: [] }) {+ const patchFn = MilvusWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue(returnValue);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, params);+ }++ it('should set db.operation.name = "SEARCH"', async () => {+ await runSearch({ collection_name: 'embeddings', vectors: [[0.1]], topk: 10 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'SEARCH'+ );+ });++ it('should set db.collection.name from collection_name param', async () => {+ await runSearch({ collection_name: 'my_embeddings', vectors: [[0.1]], topk: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_COLLECTION_NAME,+ 'my_embeddings'+ );+ });++ it('should set db.vector.query.top_k from topk param', async () => {+ await runSearch({ collection_name: 'col', vectors: [[0.1]], topk: 20 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_QUERY_TOP_K, 20);+ });++ it('should also accept "limit" as top_k param', async () => {+ await runSearch({ collection_name: 'col', vectors: [[0.1]], limit: 15 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_QUERY_TOP_K, 15);+ });++ it('should set db.filter when expr provided', async () => {+ await runSearch({+ collection_name: 'col',+ vectors: [[0.1]],+ topk: 5,+ expr: 'category == "books"',+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ 'category == "books"'+ );+ });++ it('should set db.n_results from results length', async () => {+ await runSearch(+ { collection_name: 'col', vectors: [[0.1]], topk: 5 },+ { results: [{ id: 1 }, { id: 2 }] }+ );++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_N_RESULTS, 2);+ });+ });++ // ── insert → INSERT ───────────────────────────────────────────────────────++ describe('insert() → INSERT (matches Python DB_OPERATION_INSERT)', () => {+ async function runInsert(params: any) {+ const patchFn = MilvusWrapper._patchInsert(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ insert_cnt: params.data?.length ?? 0 });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, params);+ }++ it('should set db.operation.name = "INSERT"', async () => {+ await runInsert({ collection_name: 'col', data: [{ id: 1, vector: [0.1] }] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'INSERT'+ );+ });++ it('should set db.vector.count from data length', async () => {+ await runInsert({+ collection_name: 'col',+ data: [{ id: 1 }, { id: 2 }, { id: 3 }],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_COUNT, 3);+ });++ it('should also work with collectionName (camelCase) param', async () => {+ const patchFn = MilvusWrapper._patchInsert(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({});+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, { collectionName: 'camelCase', data: [{ id: 1 }] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_COLLECTION_NAME,+ 'camelCase'+ );+ });+ });++ // ── upsert → UPSERT ───────────────────────────────────────────────────────++ describe('upsert() → UPSERT', () => {+ it('should set db.operation.name = "UPSERT" and db.vector.count', async () => {+ const patchFn = MilvusWrapper._patchUpsert(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({});+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, {+ collection_name: 'col',+ data: [{ id: 1, vector: [0.1] }, { id: 2, vector: [0.2] }],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'UPSERT'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_COUNT, 2);+ });+ });++ // ── delete → DELETE ───────────────────────────────────────────────────────++ describe('delete() → DELETE', () => {+ it('should set db.operation.name = "DELETE"', async () => {+ const patchFn = MilvusWrapper._patchDelete(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ delete_cnt: 2 });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, {+ collection_name: 'col',+ ids: [1, 2],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'DELETE'+ );+ });++ it('should set db.filter when expr provided', async () => {+ const patchFn = MilvusWrapper._patchDelete(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({});+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, {+ collection_name: 'col',+ expr: 'id in [1, 2, 3]',+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ 'id in [1, 2, 3]'+ );+ });++ it('should set db.ids_count when ids provided', async () => {+ const patchFn = MilvusWrapper._patchDelete(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({});+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, { collection_name: 'col', ids: [10, 20, 30] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_ID_COUNT, 3);+ });+ });++ // ── query → QUERY ─────────────────────────────────────────────────────────++ describe('query() → QUERY (scalar filter query)', () => {+ it('should set db.operation.name = "QUERY"', async () => {+ const patchFn = MilvusWrapper._patchQuery(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ data: [{ id: 1 }, { id: 2 }] });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, {+ collection_name: 'col',+ expr: 'category == "books"',+ limit: 50,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'QUERY'+ );+ });++ it('should set db.n_results from data length', async () => {+ const patchFn = MilvusWrapper._patchQuery(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ data: [{ id: 1 }, { id: 2 }, { id: 3 }] });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, { collection_name: 'col', expr: 'id > 0' });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_N_RESULTS, 3);+ });+ });++ // ── Error handling ────────────────────────────────────────────────────────++ it('should call handleException and end span on error', async () => {+ const patchFn = MilvusWrapper._patchSearch(mockTracer);+ const error = new Error('Milvus not available');+ const originalMethod = jest.fn().mockRejectedValue(error);+ const wrapped = patchFn(originalMethod);++ await expect(wrapped.call({}, { collection_name: 'col', vectors: [[0.1]], topk: 5 })).rejects.toThrow();+ expect(OpenLitHelper.handleException).toHaveBeenCalledWith(mockSpan, error);+ expect(mockSpan.end).toHaveBeenCalled();+ });+});diff --git a/sdk/typescript/src/instrumentation/__tests__/qdrant-trace-comparison.test.ts b/sdk/typescript/src/instrumentation/__tests__/qdrant-trace-comparison.test.tsnew file mode 100644index 00000000..44dd8f24--- /dev/null+++ b/sdk/typescript/src/instrumentation/__tests__/qdrant-trace-comparison.test.ts@@ -0,0 +1,249 @@+/**+ * Cross-Language Trace Comparison Tests for Qdrant Integration+ *+ * Verifies TypeScript SDK trace attributes match Python SDK.+ *+ * Python SDK reference: sdk/python/src/openlit/instrumentation/qdrant/utils.py+ *+ * Key alignment:+ * - db.system.name = 'qdrant'+ * - db.operation.name: SEARCH, UPSERT, DELETE, GET+ * - server.address, server.port (default localhost:6333)+ * - db.vector.query.top_k for search+ * - db.filter for filtered operations+ * - db.vector.count for upsert+ * - db.query.summary+ */++import QdrantWrapper from '../qdrant/wrapper';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';++jest.mock('../../config');+jest.mock('../../helpers');++describe('Qdrant Cross-Language Trace Comparison', () => {+ let mockSpan: any;+ let mockTracer: any;++ beforeEach(() => {+ mockSpan = {+ setAttribute: jest.fn(),+ addEvent: jest.fn(),+ end: jest.fn(),+ setStatus: jest.fn(),+ };++ mockTracer = {+ startSpan: jest.fn().mockReturnValue(mockSpan),+ };++ (OpenlitConfig as any).environment = 'openlit-testing';+ (OpenlitConfig as any).applicationName = 'openlit-test';+ (OpenlitConfig as any).traceContent = true;+ (OpenLitHelper as any).handleException = jest.fn();+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ // ── Common attributes ────────────────────────────────────────────────────++ it('should set db.system.name = "qdrant" matching Python DB_SYSTEM_QDRANT', async () => {+ const patchFn = QdrantWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue([{ id: 1, score: 0.9 }]);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, 'my_collection', { vector: [0.1, 0.2], limit: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_SYSTEM_NAME, 'qdrant');+ });++ it('should set server.address = localhost and server.port = 6333 (Python defaults)', async () => {+ const patchFn = QdrantWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue([]);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, 'col', { vector: [0.1], limit: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_ADDRESS, 'localhost');+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_PORT, 6333);+ });++ // ── search → SEARCH ───────────────────────────────────────────────────────++ describe('search() → SEARCH (matches Python DB_OPERATION_SEARCH)', () => {+ async function runSearch(collectionName: string, params: any, returnValue: any = []) {+ const patchFn = QdrantWrapper._patchSearch(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue(returnValue);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, collectionName, params);+ }++ it('should set db.operation.name = "SEARCH"', async () => {+ await runSearch('my_col', { vector: [0.1, 0.2], limit: 10 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'SEARCH'+ );+ });++ it('should set db.collection.name', async () => {+ await runSearch('embeddings', { vector: [0.1], limit: 5 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_COLLECTION_NAME,+ 'embeddings'+ );+ });++ it('should set db.vector.query.top_k from limit param', async () => {+ await runSearch('col', { vector: [0.1], limit: 20 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_QUERY_TOP_K, 20);+ });++ it('should set db.filter when filter provided', async () => {+ const filter = { must: [{ key: 'city', match: { value: 'Paris' } }] };+ await runSearch('col', { vector: [0.1], limit: 5, filter });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ JSON.stringify(filter)+ );+ });++ it('should set db.n_results to response array length', async () => {+ await runSearch('col', { vector: [0.1], limit: 5 }, [+ { id: 1, score: 0.9 },+ { id: 2, score: 0.8 },+ ]);++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_N_RESULTS, 2);+ });+ });++ // ── upsert → UPSERT ───────────────────────────────────────────────────────++ describe('upsert() → UPSERT (matches Python DB_OPERATION_UPSERT)', () => {+ async function runUpsert(collectionName: string, params: any) {+ const patchFn = QdrantWrapper._patchUpsert(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ status: 'completed' });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, collectionName, params);+ }++ it('should set db.operation.name = "UPSERT"', async () => {+ await runUpsert('col', { points: [{ id: 1, vector: [0.1], payload: {} }] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'UPSERT'+ );+ });++ it('should set db.vector.count from points length', async () => {+ await runUpsert('col', {+ points: [+ { id: 1, vector: [0.1] },+ { id: 2, vector: [0.2] },+ { id: 3, vector: [0.3] },+ ],+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_VECTOR_COUNT, 3);+ });+ });++ // ── delete → DELETE ───────────────────────────────────────────────────────++ describe('delete() → DELETE (matches Python DB_OPERATION_DELETE)', () => {+ async function runDelete(collectionName: string, params: any) {+ const patchFn = QdrantWrapper._patchDelete(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ status: 'completed' });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, collectionName, params);+ }++ it('should set db.operation.name = "DELETE"', async () => {+ await runDelete('col', { points: [1, 2] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'DELETE'+ );+ });++ it('should set db.ids_count from points array', async () => {+ await runDelete('col', { points: [1, 2, 3] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_ID_COUNT, 3);+ });++ it('should set db.filter when filter provided', async () => {+ const filter = { must: [{ key: 'city', match: { value: 'London' } }] };+ await runDelete('col', { filter });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_FILTER,+ JSON.stringify(filter)+ );+ });+ });++ // ── retrieve → GET ────────────────────────────────────────────────────────++ describe('retrieve() → GET (matches Python DB_OPERATION_GET)', () => {+ it('should set db.operation.name = "GET"', async () => {+ const patchFn = QdrantWrapper._patchRetrieve(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue([{ id: 1 }, { id: 2 }]);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, 'col', { ids: [1, 2] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'GET'+ );+ });++ it('should set db.ids_count and db.response.returned_rows', async () => {+ const patchFn = QdrantWrapper._patchRetrieve(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue([{ id: 1 }, { id: 2 }]);+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, 'col', { ids: [1, 2] });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_ID_COUNT, 2);+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, 2);+ });+ });++ // ── scroll → GET ─────────────────────────────────────────────────────────++ describe('scroll() → GET (matches Python DB_OPERATION_GET)', () => {+ it('should set db.operation.name = "GET"', async () => {+ const patchFn = QdrantWrapper._patchScroll(mockTracer);+ const originalMethod = jest.fn().mockResolvedValue({ points: [{ id: 1 }, { id: 2 }] });+ const wrapped = patchFn(originalMethod);+ await wrapped.call({}, 'col', { limit: 100 });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.DB_OPERATION_NAME,+ 'GET'+ );+ });+ });++ // ── Error handling ────────────────────────────────────────────────────────++ it('should call handleException and end span on error', async () => {+ const patchFn = QdrantWrapper._patchSearch(mockTracer);+ const error = new Error('Qdrant connection refused');+ const originalMethod = jest.fn().mockRejectedValue(error);+ const wrapped = patchFn(originalMethod);++ await expect(wrapped.call({}, 'col', { vector: [0.1], limit: 5 })).rejects.toThrow();+ expect(OpenLitHelper.handleException).toHaveBeenCalledWith(mockSpan, error);+ expect(mockSpan.end).toHaveBeenCalled();+ });+});diff --git a/sdk/typescript/src/instrumentation/__tests__/replicate-trace-comparison.test.ts b/sdk/typescript/src/instrumentation/__tests__/replicate-trace-comparison.test.tsnew file mode 100644index 00000000..9b7f08b5--- /dev/null+++ b/sdk/typescript/src/instrumentation/__tests__/replicate-trace-comparison.test.ts@@ -0,0 +1,206 @@+/**+ * Trace Comparison Tests for Replicate Integration+ *+ * Verifies that the TypeScript SDK generates consistent traces for+ * Replicate model runs.+ */++import ReplicateWrapper from '../replicate/wrapper';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import BaseWrapper from '../base-wrapper';+import SemanticConvention from '../../semantic-convention';++jest.mock('../../config');+jest.mock('../../helpers');+jest.mock('../base-wrapper');++describe('Replicate Trace Comparison', () => {+ let mockSpan: any;++ beforeEach(() => {+ mockSpan = {+ setAttribute: jest.fn(),+ addEvent: jest.fn(),+ end: jest.fn(),+ setStatus: jest.fn(),+ };++ (OpenlitConfig as any).environment = 'openlit-testing';+ (OpenlitConfig as any).applicationName = 'openlit-test';+ (OpenlitConfig as any).traceContent = true;+ (OpenlitConfig as any).pricing_json = {};+ (OpenlitConfig as any).updatePricingJson = jest.fn().mockResolvedValue({});++ (OpenLitHelper as any).getChatModelCost = jest.fn().mockReturnValue(0.001);+ (OpenLitHelper as any).generalTokens = jest.fn().mockReturnValue(10);+ (OpenLitHelper as any).handleException = jest.fn();++ (BaseWrapper as any).recordMetrics = jest.fn();+ (BaseWrapper as any).setBaseSpanAttributes = jest.fn().mockImplementation((span: any, attrs: any) => {+ span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME, attrs.aiSystem);+ span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, attrs.genAIEndpoint);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, attrs.model);+ if (attrs.cost !== undefined) span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, attrs.cost);+ if (attrs.serverAddress) span.setAttribute(SemanticConvention.SERVER_ADDRESS, attrs.serverAddress);+ if (attrs.serverPort !== undefined) span.setAttribute(SemanticConvention.SERVER_PORT, attrs.serverPort);+ span.setAttribute(SemanticConvention.GEN_AI_SDK_VERSION, '1.9.0');+ });+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ describe('run() — text output', () => {+ const identifier = 'meta/llama-2-70b-chat';+ const mockArgs = [+ identifier,+ { input: { prompt: 'What is the capital of France?' } },+ ];++ it('should set gen_ai.system = "replicate"', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ 'replicate'+ );+ });++ it('should set gen_ai.request.model stripped of version hash', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_REQUEST_MODEL,+ 'meta/llama-2-70b-chat'+ );+ });++ it('should strip version hash from identifier with colon', async () => {+ const argsWithVersion = [+ 'stability-ai/sdxl:abc123def456',+ { input: { prompt: 'A sunset over mountains' } },+ ];++ await ReplicateWrapper._run({+ args: argsWithVersion,+ genAIEndpoint: 'replicate.run',+ response: ['https://example.com/image.png'],+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_REQUEST_MODEL,+ 'stability-ai/sdxl'+ );+ });++ it('should set text_completion operation', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OPERATION,+ SemanticConvention.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION+ );+ });++ it('should set output_type=text for string responses', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OUTPUT_TYPE,+ SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT+ );+ });++ it('should set output_type=text for array responses (streaming text chunks)', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: ['Par', 'is', '.'],+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OUTPUT_TYPE,+ SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT+ );+ });++ it('should set output_type=json for object responses', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: { answer: 'Paris', confidence: 0.99 },+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_OUTPUT_TYPE,+ SemanticConvention.GEN_AI_OUTPUT_TYPE_JSON+ );+ });++ it('should set server.address = api.replicate.com and port 443', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.SERVER_ADDRESS,+ 'api.replicate.com'+ );+ expect(mockSpan.setAttribute).toHaveBeenCalledWith(SemanticConvention.SERVER_PORT, 443);+ });++ it('should capture prompt content when traceContent=true', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.setAttribute).toHaveBeenCalledWith(+ SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,+ 'What is the capital of France?'+ );+ });++ it('should end span and record metrics', async () => {+ await ReplicateWrapper._run({+ args: mockArgs,+ genAIEndpoint: 'replicate.run',+ response: 'Paris.',+ span: mockSpan,+ });++ expect(mockSpan.end).toHaveBeenCalled();+ expect(BaseWrapper.recordMetrics).toHaveBeenCalled();+ });+ });+});diff --git a/sdk/typescript/src/instrumentation/__tests__/trace-comparison-utils.ts b/sdk/typescript/src/instrumentation/__tests__/trace-comparison-utils.tsindex 7dc30bc1..bcf19fd4 100644--- a/sdk/typescript/src/instrumentation/__tests__/trace-comparison-utils.ts+++ b/sdk/typescript/src/instrumentation/__tests__/trace-comparison-utils.ts@@ -3,10 +3,12 @@** This module provides utilities to compare traces generated by Python and TypeScript* OpenLIT SDKs to ensure consistency across implementations.+ * Uses SemanticConvention keys so comparisons stay in sync with the SDK.*/import { Span, SpanStatusCode } from '@opentelemetry/api';import { ReadableSpan } from '@opentelemetry/sdk-trace-base';+import SemanticConvention from '../../semantic-convention';export interface NormalizedTrace {spanName: string;@@ -133,22 +135,23 @@ function compareAttributes(const differences: string[] = [];const allKeys = new Set([...Object.keys(pythonAttrs), ...Object.keys(typescriptAttrs)]);- // Critical attributes that must match+ // Critical attributes that must match (use SemanticConvention so keys stay in sync)const criticalAttributes = [- 'gen_ai.system',- 'gen_ai.operation.name',- 'gen_ai.request.model',- 'gen_ai.response.model',- 'gen_ai.usage.input_tokens',- 'gen_ai.usage.output_tokens',- 'gen_ai.usage.total_tokens',- 'gen_ai.usage.cost',- 'gen_ai.endpoint',- 'gen_ai.environment',- 'gen_ai.application_name',- 'server.address',- 'server.port',- 'gen_ai.sdk.version',+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL,+ SemanticConvention.GEN_AI_OPERATION,+ SemanticConvention.GEN_AI_REQUEST_MODEL,+ SemanticConvention.GEN_AI_RESPONSE_MODEL,+ SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,+ SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,+ SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,+ SemanticConvention.GEN_AI_USAGE_COST,+ SemanticConvention.GEN_AI_ENDPOINT,+ SemanticConvention.GEN_AI_ENVIRONMENT,+ SemanticConvention.GEN_AI_APPLICATION_NAME,+ SemanticConvention.SERVER_ADDRESS,+ SemanticConvention.SERVER_PORT,+ SemanticConvention.GEN_AI_SDK_VERSION,];for (const key of allKeys) {@@ -229,14 +232,14 @@ export function extractKeyMetrics(trace: NormalizedTrace): {return {tokens: {- input: attrs['gen_ai.usage.input_tokens'] || 0,- output: attrs['gen_ai.usage.output_tokens'] || 0,- total: attrs['gen_ai.usage.total_tokens'] || 0,+ input: attrs[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] || 0,+ output: attrs[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] || 0,+ total: attrs[SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS] || 0,},- cost: attrs['gen_ai.usage.cost'] || 0,- model: attrs['gen_ai.request.model'] || attrs['gen_ai.response.model'] || '',- operation: attrs['gen_ai.operation.name'] || '',- system: attrs['gen_ai.system'] || '',+ cost: attrs[SemanticConvention.GEN_AI_USAGE_COST] || 0,+ model: attrs[SemanticConvention.GEN_AI_REQUEST_MODEL] || attrs[SemanticConvention.GEN_AI_RESPONSE_MODEL] || '',+ operation: attrs[SemanticConvention.GEN_AI_OPERATION] || '',+ system: attrs[SemanticConvention.GEN_AI_PROVIDER_NAME] || attrs[SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL] || '',};}@@ -317,20 +320,21 @@ export function createTraceValidator(}}- // Check system matches provider- if (trace.attributes['gen_ai.system'] !== providerName) {+ // Check system matches provider (legacy + OTel keys from SemanticConvention)+ const providerAttr = trace.attributes[SemanticConvention.GEN_AI_PROVIDER_NAME] ?? trace.attributes[SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL];+ if (providerAttr !== providerName) {errors.push(- `System mismatch: expected "${providerName}", got "${trace.attributes['gen_ai.system']}"`+ `System mismatch: expected "${providerName}", got "${providerAttr}"`);}// Check operation is set- if (!trace.attributes['gen_ai.operation.name']) {+ if (!trace.attributes[SemanticConvention.GEN_AI_OPERATION]) {errors.push('Missing operation name');}// Check tokens are present- if (!trace.attributes['gen_ai.usage.input_tokens'] && !trace.attributes['gen_ai.usage.output_tokens']) {+ if (!trace.attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] && !trace.attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS]) {errors.push('Missing token usage information');}diff --git a/sdk/typescript/src/instrumentation/anthropic/wrapper.ts b/sdk/typescript/src/instrumentation/anthropic/wrapper.tsindex 676ecabe..aa72e6fe 100644--- a/sdk/typescript/src/instrumentation/anthropic/wrapper.ts+++ b/sdk/typescript/src/instrumentation/anthropic/wrapper.ts@@ -254,6 +254,7 @@ export default class AnthropicWrapper extends BaseWrapper {if (system) {const systemStr = typeof system === 'string' ? system : JSON.stringify(system);span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS, systemStr);+ span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS_OTEL, systemStr);}if (traceContent) {diff --git a/sdk/typescript/src/instrumentation/base-wrapper.ts b/sdk/typescript/src/instrumentation/base-wrapper.tsindex ac53b7a8..4aca2324 100644--- a/sdk/typescript/src/instrumentation/base-wrapper.ts+++ b/sdk/typescript/src/instrumentation/base-wrapper.ts@@ -1,5 +1,5 @@import OpenlitConfig from '../config';-import { SDK_NAME, SDK_VERSION, TELEMETRY_SDK_NAME } from '../constant';+import { SDK_NAME, SDK_VERSION } from '../constant';import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';import SemanticConvention from '../semantic-convention';import { Span, SpanStatusCode } from '@opentelemetry/api';@@ -30,12 +30,9 @@ export default class BaseWrapper {throw new Error("[Openlit] OpenlitConfig.environment is not set. Please check your configuration.");}- span.setAttributes({- [TELEMETRY_SDK_NAME]: SDK_NAME,- });- span.setAttribute(TELEMETRY_SDK_NAME, SDK_NAME);span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME, aiSystem);+ span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL, aiSystem);span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, genAIEndpoint);span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);@@ -63,10 +60,11 @@ export default class BaseWrapper {const inputTokens = BaseWrapper.getSpanAttribute(span, SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS);const outputTokens = BaseWrapper.getSpanAttribute(span, SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS);- const duration = BaseWrapper.getSpanAttribute(span, 'duration') ?? BaseWrapper.getSpanAttribute(span, 'gen_ai.duration');+ const duration = BaseWrapper.getSpanAttribute(span, 'duration') ?? BaseWrapper.getSpanAttribute(span, SemanticConvention.GEN_AI_DURATION_LEGACY);const attributes = {[ATTR_SERVICE_NAME]: applicationName,[SemanticConvention.GEN_AI_PROVIDER_NAME]: aiSystem,+ [SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL]: aiSystem,[SemanticConvention.GEN_AI_ENDPOINT]: genAIEndpoint,[SemanticConvention.ATTR_DEPLOYMENT_ENVIRONMENT]: environment,[SemanticConvention.GEN_AI_REQUEST_MODEL]: model,diff --git a/sdk/typescript/src/instrumentation/bedrock/wrapper.ts b/sdk/typescript/src/instrumentation/bedrock/wrapper.tsindex 37c62724..63825a43 100644--- a/sdk/typescript/src/instrumentation/bedrock/wrapper.ts+++ b/sdk/typescript/src/instrumentation/bedrock/wrapper.ts@@ -133,10 +133,9 @@ class BedrockWrapper extends BaseWrapper {OpenLitHelper.buildInputMessages(messages, systemText));if (systemText) {- span.setAttribute(- SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS,- JSON.stringify([{ type: 'text', content: systemText }])- );+ const systemStr = JSON.stringify([{ type: 'text', content: systemText }]);+ span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS, systemStr);+ span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS_OTEL, systemStr);}const outputText =response.output?.message?.content?.map((c: any) => c.text || '').join('') || '';@@ -267,10 +266,9 @@ class BedrockWrapper extends BaseWrapper {OpenLitHelper.buildInputMessages(messages, systemText));if (systemText) {- span.setAttribute(- SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS,- JSON.stringify([{ type: 'text', content: systemText }])- );+ const systemStr = JSON.stringify([{ type: 'text', content: systemText }]);+ span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS, systemStr);+ span.setAttribute(SemanticConvention.GEN_AI_SYSTEM_INSTRUCTIONS_OTEL, systemStr);}span.setAttribute(SemanticConvention.GEN_AI_OUTPUT_MESSAGES,diff --git a/sdk/typescript/src/instrumentation/chroma/index.ts b/sdk/typescript/src/instrumentation/chroma/index.tsnew file mode 100644index 00000000..6e9ac7a3--- /dev/null+++ b/sdk/typescript/src/instrumentation/chroma/index.ts@@ -0,0 +1,80 @@+import {+ InstrumentationBase,+ InstrumentationModuleDefinition,+ InstrumentationNodeModuleDefinition,+ isWrapped,+} from '@opentelemetry/instrumentation';+import { InstrumentationConfig } from '@opentelemetry/instrumentation';+import { INSTRUMENTATION_PREFIX } from '../../constant';+import SemanticConvention from '../../semantic-convention';+import ChromaWrapper from './wrapper';++export interface ChromaInstrumentationConfig extends InstrumentationConfig {}++export default class OpenlitChromaInstrumentation extends InstrumentationBase {+ constructor(config: ChromaInstrumentationConfig = {}) {+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-chroma`, '1.0.0', config);+ }++ protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {+ const module = new InstrumentationNodeModuleDefinition(+ 'chromadb',+ ['>=1.5.0'],+ (moduleExports) => {+ this._patch(moduleExports);+ return moduleExports;+ },+ (moduleExports) => {+ if (moduleExports !== undefined) {+ this._unpatch(moduleExports);+ }+ }+ );+ return [module];+ }++ public manualPatch(chroma: any): void {+ this._patch(chroma);+ }++ protected _patch(moduleExports: any) {+ try {+ const Collection = moduleExports.Collection;+ if (!Collection?.prototype) return;++ const methods: Array<[string, string]> = [+ ['add', SemanticConvention.DB_OPERATION_INSERT],+ ['query', SemanticConvention.DB_OPERATION_QUERY],+ ['get', SemanticConvention.DB_OPERATION_GET],+ ['delete', SemanticConvention.DB_OPERATION_DELETE],+ ['peek', SemanticConvention.DB_OPERATION_PEEK],+ ['update', SemanticConvention.DB_OPERATION_UPDATE],+ ['upsert', SemanticConvention.DB_OPERATION_UPSERT],+ ];++ for (const [method, dbOp] of methods) {+ if (typeof Collection.prototype[method] === 'function') {+ if (isWrapped(Collection.prototype[method])) {+ this._unwrap(Collection.prototype, method);+ }+ this._wrap(Collection.prototype, method, ChromaWrapper._patchCollectionMethod(this.tracer, dbOp));+ }+ }+ } catch (e) {+ console.error('Error in Chroma _patch method:', e);+ }+ }++ protected _unpatch(moduleExports: any) {+ try {+ const Collection = moduleExports.Collection;+ if (!Collection?.prototype) return;+ for (const method of ['add', 'query', 'get', 'delete', 'peek', 'update', 'upsert']) {+ if (typeof Collection.prototype[method] === 'function') {+ this._unwrap(Collection.prototype, method);+ }+ }+ } catch { /* ignore */ }+ }+}+diff --git a/sdk/typescript/src/instrumentation/chroma/wrapper.ts b/sdk/typescript/src/instrumentation/chroma/wrapper.tsnew file mode 100644index 00000000..bf785d4c--- /dev/null+++ b/sdk/typescript/src/instrumentation/chroma/wrapper.ts@@ -0,0 +1,127 @@+import { SpanKind, Tracer, context, trace } from '@opentelemetry/api';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';+import BaseWrapper from '../base-wrapper';++class ChromaWrapper extends BaseWrapper {+ static dbSystem = SemanticConvention.DB_SYSTEM_CHROMA;+ static serverAddress = 'localhost';+ static serverPort = 8000;++ static _setCommonAttributes(span: any, dbOperation: string, collectionName: string) {+ const applicationName = OpenlitConfig.applicationName || '';+ const environment = OpenlitConfig.environment || '';++ span.setAttribute(SemanticConvention.DB_SYSTEM_NAME, ChromaWrapper.dbSystem);+ span.setAttribute(SemanticConvention.DB_OPERATION_NAME, dbOperation);+ span.setAttribute(SemanticConvention.DB_COLLECTION_NAME, collectionName);+ span.setAttribute(SemanticConvention.SERVER_ADDRESS, ChromaWrapper.serverAddress);+ span.setAttribute(SemanticConvention.SERVER_PORT, ChromaWrapper.serverPort);+ span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);+ span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);+ }++ static _patchCollectionMethod(tracer: Tracer, dbOperation: string): any {+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ // `this` is a Collection instance; name is stored as this.name+ const collectionName: string = this?.name || 'unknown';+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;+ const params = args[0] || {};++ ChromaWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ // Operation-specific attributes+ switch (dbOperation) {+ case SemanticConvention.DB_OPERATION_QUERY: {+ const nResults = params.nResults || params.n_results || 10;+ span.setAttribute(SemanticConvention.DB_VECTOR_QUERY_TOP_K, nResults);+ if (params.where) span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.where));+ if (params.whereDocument) span.setAttribute(SemanticConvention.DB_WHERE_DOCUMENT, JSON.stringify(params.whereDocument));+ const returnedCount = response?.ids?.[0]?.length || 0;+ span.setAttribute(SemanticConvention.DB_N_RESULTS, returnedCount);+ if (OpenlitConfig.traceContent && params.queryTexts) {+ span.setAttribute(SemanticConvention.DB_QUERY_TEXT, JSON.stringify(params.queryTexts));+ }+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} n_results=${nResults}`);+ break;+ }+ case SemanticConvention.DB_OPERATION_INSERT:+ case SemanticConvention.DB_OPERATION_UPSERT: {+ const count = Array.isArray(params.ids) ? params.ids.length : (params.ids ? 1 : 0);+ span.setAttribute(SemanticConvention.DB_ID_COUNT, count);+ span.setAttribute(SemanticConvention.DB_VECTOR_COUNT, count);+ if (Array.isArray(params.documents)) {+ span.setAttribute(SemanticConvention.DB_DOCUMENTS_COUNT, params.documents.length);+ }+ if (Array.isArray(params.metadatas)) {+ span.setAttribute(SemanticConvention.DB_METADATA_COUNT, params.metadatas.length);+ }+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} count=${count}`);+ break;+ }+ case SemanticConvention.DB_OPERATION_GET: {+ const ids = params.ids;+ const idCount = Array.isArray(ids) ? ids.length : (ids ? 1 : 0);+ if (idCount > 0) span.setAttribute(SemanticConvention.DB_ID_COUNT, idCount);+ if (params.where) span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.where));+ const returnedRows = response?.ids?.length || 0;+ span.setAttribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, returnedRows);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} ids=${idCount}`);+ break;+ }+ case SemanticConvention.DB_OPERATION_DELETE: {+ const ids = params.ids;+ const idCount = Array.isArray(ids) ? ids.length : (ids ? 1 : 0);+ if (idCount > 0) span.setAttribute(SemanticConvention.DB_ID_COUNT, idCount);+ if (params.where) span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.where));+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} ids=${idCount}`);+ break;+ }+ case SemanticConvention.DB_OPERATION_PEEK: {+ const limit = params.limit || params || 10;+ span.setAttribute(SemanticConvention.DB_QUERY_LIMIT, typeof limit === 'number' ? limit : 10);+ const returnedRows = response?.ids?.length || 0;+ span.setAttribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, returnedRows);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName}`);+ break;+ }+ case SemanticConvention.DB_OPERATION_UPDATE: {+ const ids = params.ids;+ const idCount = Array.isArray(ids) ? ids.length : (ids ? 1 : 0);+ if (idCount > 0) span.setAttribute(SemanticConvention.DB_ID_COUNT, idCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} ids=${idCount}`);+ break;+ }+ }++ span.setStatus({ code: 1 }); // SpanStatusCode.OK+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }+}++export default ChromaWrapper;diff --git a/sdk/typescript/src/instrumentation/cohere/wrapper.ts b/sdk/typescript/src/instrumentation/cohere/wrapper.tsindex 6c4b8811..79f92107 100644--- a/sdk/typescript/src/instrumentation/cohere/wrapper.ts+++ b/sdk/typescript/src/instrumentation/cohere/wrapper.ts@@ -2,7 +2,6 @@ import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';import OpenlitConfig from '../../config';import OpenLitHelper from '../../helpers';import SemanticConvention from '../../semantic-convention';-import { SDK_NAME, TELEMETRY_SDK_NAME } from '../../constant';import BaseWrapper from '../base-wrapper';export default class CohereWrapper extends BaseWrapper {@@ -19,10 +18,6 @@ export default class CohereWrapper extends BaseWrapper {return context.with(trace.setSpan(context.active(), span), async () => {try {const response = await originalMethod.apply(this, args);- span.setAttributes({- [TELEMETRY_SDK_NAME]: SDK_NAME,- });-const model = response.model || 'embed-english-v2.0';const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);const cost = OpenLitHelper.getEmbedModelCost(diff --git a/sdk/typescript/src/instrumentation/groq/wrapper.ts b/sdk/typescript/src/instrumentation/groq/wrapper.tsindex 10af640b..7466a05a 100644--- a/sdk/typescript/src/instrumentation/groq/wrapper.ts+++ b/sdk/typescript/src/instrumentation/groq/wrapper.ts@@ -369,7 +369,9 @@ class GroqWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, toolArgs);}if (toolTypes.length > 0) {- span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypes.join(', '));+ const toolTypesStr = toolTypes.join(', ');+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypesStr);+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, toolTypesStr);}}diff --git a/sdk/typescript/src/instrumentation/huggingface/index.ts b/sdk/typescript/src/instrumentation/huggingface/index.tsnew file mode 100644index 00000000..72e03b78--- /dev/null+++ b/sdk/typescript/src/instrumentation/huggingface/index.ts@@ -0,0 +1,118 @@+import {+ InstrumentationBase,+ InstrumentationModuleDefinition,+ InstrumentationNodeModuleDefinition,+ isWrapped,+} from '@opentelemetry/instrumentation';+import { InstrumentationConfig } from '@opentelemetry/instrumentation';+import { INSTRUMENTATION_PREFIX } from '../../constant';+import HuggingFaceWrapper from './wrapper';++export interface HuggingFaceInstrumentationConfig extends InstrumentationConfig {}++export default class OpenlitHuggingFaceInstrumentation extends InstrumentationBase {+ constructor(config: HuggingFaceInstrumentationConfig = {}) {+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-huggingface`, '1.0.0', config);+ }++ protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {+ const module = new InstrumentationNodeModuleDefinition(+ '@huggingface/inference',+ ['>=2.0.0'],+ (moduleExports) => {+ this._patch(moduleExports);+ return moduleExports;+ },+ (moduleExports) => {+ if (moduleExports !== undefined) {+ this._unpatch(moduleExports);+ }+ }+ );+ return [module];+ }++ public manualPatch(hf: any): void {+ this._patch(hf);+ }++ // Originals saved for unpatch (v4+)+ private _origTaskFns: Record<string, any> = {};++ private _findLeafModule(namePart: string): Record<string, any> | null {+ try {+ const cache = (require as any).cache as Record<string, any>;+ const key = Object.keys(cache).find(k =>+ k.includes('@huggingface') &&+ k.includes('inference') &&+ k.endsWith(`${namePart}.js`) &&+ !k.endsWith('Stream.js')+ );+ return key ? cache[key].exports : null;+ } catch {+ return null;+ }+ }++ protected _patch(moduleExports: any) {+ try {+ const tracer = this.tracer;++ // v4+: InferenceClient sets task methods as non-configurable own properties in+ // its constructor, capturing them from leaf task modules via a getter chain.+ // Patching the leaf modules (writable exports) propagates through the getters+ // so new instances capture the patched functions.+ const chatMod = this._findLeafModule('chatCompletion');+ if (chatMod && typeof chatMod.chatCompletion === 'function' && !chatMod.__openlit_hf_patched) {+ this._origTaskFns.chatCompletion = chatMod.chatCompletion;+ chatMod.chatCompletion = HuggingFaceWrapper._patchChatCompletion(tracer)(chatMod.chatCompletion);+ chatMod.__openlit_hf_patched = true;+ }+ const textMod = this._findLeafModule('textGeneration');+ if (textMod && typeof textMod.textGeneration === 'function' && !textMod.__openlit_hf_patched) {+ this._origTaskFns.textGeneration = textMod.textGeneration;+ textMod.textGeneration = HuggingFaceWrapper._patchTextGeneration(tracer)(textMod.textGeneration);+ textMod.__openlit_hf_patched = true;+ }++ // v2/v3: Methods on the prototype+ for (const ClassName of ['HfInference', 'InferenceClient']) {+ const proto = moduleExports[ClassName]?.prototype;+ if (!proto) continue;+ if (typeof proto.chatCompletion === 'function') {+ if (isWrapped(proto.chatCompletion)) this._unwrap(proto, 'chatCompletion');+ this._wrap(proto, 'chatCompletion', HuggingFaceWrapper._patchChatCompletion(tracer));+ }+ if (typeof proto.textGeneration === 'function') {+ if (isWrapped(proto.textGeneration)) this._unwrap(proto, 'textGeneration');+ this._wrap(proto, 'textGeneration', HuggingFaceWrapper._patchTextGeneration(tracer));+ }+ }+ } catch (e) {+ console.error('Error in HuggingFace _patch method:', e);+ }+ }++ protected _unpatch(moduleExports: any) {+ try {+ // Restore leaf module originals (v4+)+ const chatMod = this._findLeafModule('chatCompletion');+ if (chatMod && this._origTaskFns.chatCompletion) {+ chatMod.chatCompletion = this._origTaskFns.chatCompletion;+ delete chatMod.__openlit_hf_patched;+ }+ const textMod = this._findLeafModule('textGeneration');+ if (textMod && this._origTaskFns.textGeneration) {+ textMod.textGeneration = this._origTaskFns.textGeneration;+ delete textMod.__openlit_hf_patched;+ }+ // Restore prototype methods (v2/v3)+ for (const ClassName of ['HfInference', 'InferenceClient']) {+ const proto = moduleExports[ClassName]?.prototype;+ if (!proto) continue;+ if (isWrapped(proto.chatCompletion)) this._unwrap(proto, 'chatCompletion');+ if (isWrapped(proto.textGeneration)) this._unwrap(proto, 'textGeneration');+ }+ } catch { /* ignore */ }+ }+}diff --git a/sdk/typescript/src/instrumentation/huggingface/wrapper.ts b/sdk/typescript/src/instrumentation/huggingface/wrapper.tsnew file mode 100644index 00000000..3c252848--- /dev/null+++ b/sdk/typescript/src/instrumentation/huggingface/wrapper.ts@@ -0,0 +1,329 @@+import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';+import BaseWrapper from '../base-wrapper';++class HuggingFaceWrapper extends BaseWrapper {+ static aiSystem = SemanticConvention.GEN_AI_SYSTEM_HUGGING_FACE;+ static serverAddress = 'api-inference.huggingface.co';+ static serverPort = 443;++ static _patchChatCompletion(tracer: Tracer): any {+ const genAIEndpoint = 'huggingface.chat.completions';+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });+ return context+ .with(trace.setSpan(context.active(), span), async () => {+ return originalMethod.apply(this, args);+ })+ .then((response: any) => {+ const { stream = false } = args[0] || {};+ if (stream) {+ return OpenLitHelper.createStreamProxy(+ response,+ HuggingFaceWrapper._chatCompletionGenerator({ args, genAIEndpoint, response, span })+ );+ }+ return HuggingFaceWrapper._chatCompletion({ args, genAIEndpoint, response, span });+ })+ .catch((e: any) => {+ OpenLitHelper.handleException(span, e);+ span.end();+ throw e;+ });+ };+ };+ }++ static async _chatCompletion({+ args,+ genAIEndpoint,+ response,+ span,+ }: {+ args: any[];+ genAIEndpoint: string;+ response: any;+ span: Span;+ }): Promise<any> {+ let metricParams;+ try {+ metricParams = await HuggingFaceWrapper._chatCompletionCommonSetter({+ args,+ genAIEndpoint,+ result: response,+ span,+ });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ if (metricParams) {+ BaseWrapper.recordMetrics(span, metricParams);+ }+ }+ }++ static async *_chatCompletionGenerator({+ args,+ genAIEndpoint,+ response,+ span,+ }: {+ args: any[];+ genAIEndpoint: string;+ response: any;+ span: Span;+ }): AsyncGenerator<unknown, any, unknown> {+ let metricParams;+ const timestamps: number[] = [];+ const startTime = Date.now();++ try {+ const { messages } = args[0] || {};+ const result = {+ id: '0',+ created: -1,+ model: args[0]?.model || '',+ choices: [+ {+ index: 0,+ finish_reason: 'stop',+ message: { role: 'assistant', content: '' },+ },+ ],+ usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },+ };++ for await (const chunk of response) {+ timestamps.push(Date.now());+ if (chunk.id) result.id = chunk.id;+ if (chunk.created) result.created = chunk.created;+ if (chunk.model) result.model = chunk.model;+ if (chunk.choices?.[0]?.finish_reason) {+ result.choices[0].finish_reason = chunk.choices[0].finish_reason;+ }+ if (chunk.choices?.[0]?.delta?.content) {+ result.choices[0].message.content += chunk.choices[0].delta.content;+ }+ yield chunk;+ }++ let promptTokens = 0;+ for (const message of messages || []) {+ promptTokens += OpenLitHelper.generalTokens(message.content as string) ?? 0;+ }+ const completionTokens = OpenLitHelper.generalTokens(result.choices[0].message.content ?? '');+ if (completionTokens) {+ result.usage = {+ prompt_tokens: promptTokens,+ completion_tokens: completionTokens,+ total_tokens: promptTokens + completionTokens,+ };+ }++ const ttft = timestamps.length > 0 ? (timestamps[0] - startTime) / 1000 : 0;+ let tbt = 0;+ if (timestamps.length > 1) {+ const timeDiffs = timestamps.slice(1).map((t, i) => t - timestamps[i]);+ tbt = timeDiffs.reduce((a, b) => a + b, 0) / timeDiffs.length / 1000;+ }++ metricParams = await HuggingFaceWrapper._chatCompletionCommonSetter({+ args,+ genAIEndpoint,+ result,+ span,+ ttft,+ tbt,+ });++ return result;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ if (metricParams) {+ BaseWrapper.recordMetrics(span, metricParams);+ }+ }+ }++ static async _chatCompletionCommonSetter({+ args,+ genAIEndpoint,+ result,+ span,+ ttft = 0,+ tbt = 0,+ }: {+ args: any[];+ genAIEndpoint: string;+ result: any;+ span: Span;+ ttft?: number;+ tbt?: number;+ }) {+ const traceContent = OpenlitConfig.traceContent;+ const {+ messages,+ model,+ max_tokens = null,+ temperature = 1,+ top_p,+ stream = false,+ } = args[0] || {};++ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, top_p || 1);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, max_tokens || -1);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, temperature);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, stream);++ if (traceContent) {+ span.setAttribute(SemanticConvention.GEN_AI_INPUT_MESSAGES, OpenLitHelper.buildInputMessages(messages || []));+ }++ span.setAttribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT);++ if (result.id) span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_ID, result.id);++ const responseModel = result.model || model || '';+ const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);+ const cost = OpenLitHelper.getChatModelCost(+ responseModel,+ pricingInfo,+ result.usage?.prompt_tokens || 0,+ result.usage?.completion_tokens || 0+ );++ HuggingFaceWrapper.setBaseSpanAttributes(span, {+ genAIEndpoint,+ model: responseModel,+ cost,+ aiSystem: HuggingFaceWrapper.aiSystem,+ serverAddress: HuggingFaceWrapper.serverAddress,+ serverPort: HuggingFaceWrapper.serverPort,+ });++ span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_MODEL, responseModel);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, result.usage?.prompt_tokens || 0);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, result.usage?.completion_tokens || 0);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, result.usage?.total_tokens || 0);+ span.setAttribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, result.usage?.total_tokens || 0);++ if (ttft > 0) span.setAttribute(SemanticConvention.GEN_AI_SERVER_TTFT, ttft);+ if (tbt > 0) span.setAttribute(SemanticConvention.GEN_AI_SERVER_TBT, tbt);++ if (result.choices?.[0]?.finish_reason) {+ span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [result.choices[0].finish_reason]);+ }+ span.setAttribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT);++ if (traceContent && result.choices?.[0]?.message) {+ span.setAttribute(+ SemanticConvention.GEN_AI_OUTPUT_MESSAGES,+ OpenLitHelper.buildOutputMessages(+ result.choices[0].message.content || '',+ result.choices[0].finish_reason || 'stop'+ )+ );+ }++ return { genAIEndpoint, model: responseModel, cost, aiSystem: HuggingFaceWrapper.aiSystem };+ }++ // ── Text Generation ──────────────────────────────────────────────────────────++ static _patchTextGeneration(tracer: Tracer): any {+ const genAIEndpoint = 'huggingface.text.generation';+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });+ return context+ .with(trace.setSpan(context.active(), span), async () => {+ return originalMethod.apply(this, args);+ })+ .then((response: any) =>+ HuggingFaceWrapper._textGeneration({ args, genAIEndpoint, response, span })+ )+ .catch((e: any) => {+ OpenLitHelper.handleException(span, e);+ span.end();+ throw e;+ });+ };+ };+ }++ static async _textGeneration({+ args,+ genAIEndpoint,+ response,+ span,+ }: {+ args: any[];+ genAIEndpoint: string;+ response: any;+ span: Span;+ }): Promise<any> {+ let metricParams;+ try {+ const traceContent = OpenlitConfig.traceContent;+ const { model = '', inputs = '', parameters = {} } = args[0] || {};+ const { max_new_tokens = null, temperature = 1 } = parameters;++ span.setAttribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, max_new_tokens || -1);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, temperature);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, false);++ if (traceContent) {+ span.setAttribute(SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT, inputs);+ }++ const generatedText: string = response?.generated_text || '';+ const promptTokens = OpenLitHelper.generalTokens(inputs) ?? 0;+ const completionTokens = OpenLitHelper.generalTokens(generatedText) ?? 0;++ const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);+ const cost = OpenLitHelper.getChatModelCost(model, pricingInfo, promptTokens, completionTokens);++ HuggingFaceWrapper.setBaseSpanAttributes(span, {+ genAIEndpoint,+ model,+ cost,+ aiSystem: HuggingFaceWrapper.aiSystem,+ serverAddress: HuggingFaceWrapper.serverAddress,+ serverPort: HuggingFaceWrapper.serverPort,+ });++ span.setAttribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, promptTokens);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, completionTokens);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, promptTokens + completionTokens);+ span.setAttribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, promptTokens + completionTokens);+ span.setAttribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT);++ if (traceContent) {+ span.setAttribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT, generatedText);+ }++ metricParams = { genAIEndpoint, model, cost, aiSystem: HuggingFaceWrapper.aiSystem };+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ if (metricParams) {+ BaseWrapper.recordMetrics(span, metricParams);+ }+ }+ }+}++export default HuggingFaceWrapper;diff --git a/sdk/typescript/src/instrumentation/index.ts b/sdk/typescript/src/instrumentation/index.tsindex f5cffacc..33063da0 100644--- a/sdk/typescript/src/instrumentation/index.ts+++ b/sdk/typescript/src/instrumentation/index.ts@@ -15,6 +15,11 @@ import LangChainInstrumentation from './langchain';import PineconeInstrumentation from './pinecone';import BedrockInstrumentation from './bedrock';import LlamaIndexInstrumentation from './llamaindex';+import HuggingFaceInstrumentation from './huggingface';+import ReplicateInstrumentation from './replicate';+import ChromaInstrumentation from './chroma';+import QdrantInstrumentation from './qdrant';+import MilvusInstrumentation from './milvus';export default class Instrumentations {static availableInstrumentations: OpenlitInstrumentations = {@@ -31,6 +36,11 @@ export default class Instrumentations {pinecone: new PineconeInstrumentation(),bedrock: new BedrockInstrumentation(),llamaindex: new LlamaIndexInstrumentation(),+ huggingface: new HuggingFaceInstrumentation(),+ replicate: new ReplicateInstrumentation(),+ chroma: new ChromaInstrumentation(),+ qdrant: new QdrantInstrumentation(),+ milvus: new MilvusInstrumentation(),};static setup(diff --git a/sdk/typescript/src/instrumentation/langchain/wrapper.ts b/sdk/typescript/src/instrumentation/langchain/wrapper.tsindex ffc629b0..3a052b30 100644--- a/sdk/typescript/src/instrumentation/langchain/wrapper.ts+++ b/sdk/typescript/src/instrumentation/langchain/wrapper.ts@@ -104,6 +104,7 @@ class OpenLITCallbackHandler {);span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME, provider);+ span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL, provider);span.setAttribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT);span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, OpenlitConfig.environment || '');span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, OpenlitConfig.applicationName || '');@@ -286,6 +287,7 @@ class OpenLITCallbackHandler {);span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN);+ span.setAttribute(SemanticConvention.GEN_AI_PROVIDER_NAME_OTEL, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN);span.setAttribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK);span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, OpenlitConfig.environment || '');span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, OpenlitConfig.applicationName || '');diff --git a/sdk/typescript/src/instrumentation/milvus/index.ts b/sdk/typescript/src/instrumentation/milvus/index.tsnew file mode 100644index 00000000..b011bb91--- /dev/null+++ b/sdk/typescript/src/instrumentation/milvus/index.ts@@ -0,0 +1,76 @@+import {+ InstrumentationBase,+ InstrumentationModuleDefinition,+ InstrumentationNodeModuleDefinition,+ isWrapped,+} from '@opentelemetry/instrumentation';+import { InstrumentationConfig } from '@opentelemetry/instrumentation';+import { INSTRUMENTATION_PREFIX } from '../../constant';+import MilvusWrapper from './wrapper';++export interface MilvusInstrumentationConfig extends InstrumentationConfig {}++export default class OpenlitMilvusInstrumentation extends InstrumentationBase {+ constructor(config: MilvusInstrumentationConfig = {}) {+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-milvus`, '1.0.0', config);+ }++ protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {+ const module = new InstrumentationNodeModuleDefinition(+ '@zilliz/milvus2-sdk-node',+ ['>=2.0.0'],+ (moduleExports) => {+ this._patch(moduleExports);+ return moduleExports;+ },+ (moduleExports) => {+ if (moduleExports !== undefined) {+ this._unpatch(moduleExports);+ }+ }+ );+ return [module];+ }++ public manualPatch(milvus: any): void {+ this._patch(milvus);+ }++ protected _patch(moduleExports: any) {+ try {+ const MilvusClient = moduleExports.MilvusClient;+ if (!MilvusClient?.prototype) return;++ const patchMap: Array<[string, (tracer: any) => any]> = [+ ['search', MilvusWrapper._patchSearch.bind(MilvusWrapper)],+ ['insert', MilvusWrapper._patchInsert.bind(MilvusWrapper)],+ ['delete', MilvusWrapper._patchDelete.bind(MilvusWrapper)],+ ['query', MilvusWrapper._patchQuery.bind(MilvusWrapper)],+ ['upsert', MilvusWrapper._patchUpsert.bind(MilvusWrapper)],+ ];++ for (const [method, patchFn] of patchMap) {+ if (typeof MilvusClient.prototype[method] === 'function') {+ if (isWrapped(MilvusClient.prototype[method])) {+ this._unwrap(MilvusClient.prototype, method);+ }+ this._wrap(MilvusClient.prototype, method, patchFn(this.tracer));+ }+ }+ } catch (e) {+ console.error('Error in Milvus _patch method:', e);+ }+ }++ protected _unpatch(moduleExports: any) {+ try {+ const MilvusClient = moduleExports.MilvusClient;+ if (!MilvusClient?.prototype) return;+ for (const method of ['search', 'insert', 'delete', 'query', 'upsert']) {+ if (typeof MilvusClient.prototype[method] === 'function') {+ this._unwrap(MilvusClient.prototype, method);+ }+ }+ } catch { /* ignore */ }+ }+}diff --git a/sdk/typescript/src/instrumentation/milvus/wrapper.ts b/sdk/typescript/src/instrumentation/milvus/wrapper.tsnew file mode 100644index 00000000..27067c30--- /dev/null+++ b/sdk/typescript/src/instrumentation/milvus/wrapper.ts@@ -0,0 +1,243 @@+import { SpanKind, Tracer, context, trace } from '@opentelemetry/api';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';+import BaseWrapper from '../base-wrapper';++class MilvusWrapper extends BaseWrapper {+ static dbSystem = SemanticConvention.DB_SYSTEM_MILVUS;+ static serverAddress = 'localhost';+ static serverPort = 19530;++ static _setCommonAttributes(span: any, dbOperation: string, collectionName: string) {+ const applicationName = OpenlitConfig.applicationName || '';+ const environment = OpenlitConfig.environment || '';++ span.setAttribute(SemanticConvention.DB_SYSTEM_NAME, MilvusWrapper.dbSystem);+ span.setAttribute(SemanticConvention.DB_OPERATION_NAME, dbOperation);+ span.setAttribute(SemanticConvention.DB_COLLECTION_NAME, collectionName);+ span.setAttribute(SemanticConvention.SERVER_ADDRESS, MilvusWrapper.serverAddress);+ span.setAttribute(SemanticConvention.SERVER_PORT, MilvusWrapper.serverPort);+ span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);+ span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);+ }++ // Milvus SDK uses `collection_name` in params for most methods+ static _getCollectionName(params: any): string {+ return params?.collection_name || params?.collectionName || 'unknown';+ }++ static _patchSearch(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_SEARCH;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const params = args[0] || {};+ const collectionName = MilvusWrapper._getCollectionName(params);+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ MilvusWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);+ span.setAttribute(SemanticConvention.DB_VECTOR_QUERY_TOP_K, params.topk || params.limit || 10);++ if (params.expr || params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, params.expr || params.filter);+ }+ if (params.output_fields) {+ span.setAttribute(SemanticConvention.DB_OUTPUT_FIELDS, JSON.stringify(params.output_fields));+ }++ const resultCount = response?.results?.length || 0;+ span.setAttribute(SemanticConvention.DB_N_RESULTS, resultCount);++ if (OpenlitConfig.traceContent && params.vectors) {+ const vectors = Array.isArray(params.vectors) ? params.vectors : [];+ span.setAttribute(SemanticConvention.DB_QUERY_TEXT,+ JSON.stringify(vectors.slice(0, 1).map((v: number[]) => v?.slice(0, 10))));+ }++ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} topk=${params.topk || params.limit || 10}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchInsert(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_INSERT;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const params = args[0] || {};+ const collectionName = MilvusWrapper._getCollectionName(params);+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ MilvusWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ const data = params.data || params.fields_data || [];+ const rowCount = Array.isArray(data) ? data.length : 0;+ span.setAttribute(SemanticConvention.DB_VECTOR_COUNT, rowCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} rows=${rowCount}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchUpsert(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_UPSERT;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const params = args[0] || {};+ const collectionName = MilvusWrapper._getCollectionName(params);+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ MilvusWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ const data = params.data || params.fields_data || [];+ const rowCount = Array.isArray(data) ? data.length : 0;+ span.setAttribute(SemanticConvention.DB_VECTOR_COUNT, rowCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} rows=${rowCount}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchDelete(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_DELETE;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const params = args[0] || {};+ const collectionName = MilvusWrapper._getCollectionName(params);+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ MilvusWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ if (params.expr || params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, params.expr || params.filter);+ }+ const ids = params.ids || [];+ if (Array.isArray(ids) && ids.length > 0) {+ span.setAttribute(SemanticConvention.DB_ID_COUNT, ids.length);+ }+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchQuery(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_QUERY;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const params = args[0] || {};+ const collectionName = MilvusWrapper._getCollectionName(params);+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ MilvusWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ if (params.expr || params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, params.expr || params.filter);+ }+ if (params.limit) {+ span.setAttribute(SemanticConvention.DB_QUERY_LIMIT, params.limit);+ }+ if (params.output_fields) {+ span.setAttribute(SemanticConvention.DB_OUTPUT_FIELDS, JSON.stringify(params.output_fields));+ }++ const resultCount = response?.data?.length || 0;+ span.setAttribute(SemanticConvention.DB_N_RESULTS, resultCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} results=${resultCount}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }+}++export default MilvusWrapper;diff --git a/sdk/typescript/src/instrumentation/mistral/wrapper.ts b/sdk/typescript/src/instrumentation/mistral/wrapper.tsindex df29b061..04f8f5d1 100644--- a/sdk/typescript/src/instrumentation/mistral/wrapper.ts+++ b/sdk/typescript/src/instrumentation/mistral/wrapper.ts@@ -261,7 +261,7 @@ class MistralWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_REQUEST_USER, user);}if (safe_prompt !== undefined) {- span.setAttribute('gen_ai.request.safe_prompt', safe_prompt);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_SAFE_PROMPT, safe_prompt);}if (traceContent) {@@ -347,7 +347,9 @@ class MistralWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, toolArgs);}if (toolTypes.length > 0) {- span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypes.join(', '));+ const toolTypesStr = toolTypes.join(', ');+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypesStr);+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, toolTypesStr);}}diff --git a/sdk/typescript/src/instrumentation/openai/wrapper.ts b/sdk/typescript/src/instrumentation/openai/wrapper.tsindex b461e0fd..98000e45 100644--- a/sdk/typescript/src/instrumentation/openai/wrapper.ts+++ b/sdk/typescript/src/instrumentation/openai/wrapper.ts@@ -417,7 +417,9 @@ class OpenAIWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, toolArgs);}if (toolTypes.length > 0) {- span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypes.join(', '));+ const toolTypesStr = toolTypes.join(', ');+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypesStr);+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, toolTypesStr);}}@@ -1090,7 +1092,7 @@ class OpenAIWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, stream);if (reasoning?.effort) {- span.setAttribute('gen_ai.request.reasoning_effort', reasoning.effort);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_REASONING_EFFORT, reasoning.effort);}if (traceContent) {@@ -1191,7 +1193,9 @@ class OpenAIWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, toolArgs.join(', '));}if (toolTypes.length > 0) {- span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypes.join(', '));+ const toolTypesStr = toolTypes.join(', ');+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypesStr);+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, toolTypesStr);}}diff --git a/sdk/typescript/src/instrumentation/qdrant/index.ts b/sdk/typescript/src/instrumentation/qdrant/index.tsnew file mode 100644index 00000000..b20f2dc0--- /dev/null+++ b/sdk/typescript/src/instrumentation/qdrant/index.ts@@ -0,0 +1,76 @@+import {+ InstrumentationBase,+ InstrumentationModuleDefinition,+ InstrumentationNodeModuleDefinition,+ isWrapped,+} from '@opentelemetry/instrumentation';+import { InstrumentationConfig } from '@opentelemetry/instrumentation';+import { INSTRUMENTATION_PREFIX } from '../../constant';+import QdrantWrapper from './wrapper';++export interface QdrantInstrumentationConfig extends InstrumentationConfig {}++export default class OpenlitQdrantInstrumentation extends InstrumentationBase {+ constructor(config: QdrantInstrumentationConfig = {}) {+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-qdrant`, '1.0.0', config);+ }++ protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {+ const module = new InstrumentationNodeModuleDefinition(+ '@qdrant/js-client-rest',+ ['>=1.0.0'],+ (moduleExports) => {+ this._patch(moduleExports);+ return moduleExports;+ },+ (moduleExports) => {+ if (moduleExports !== undefined) {+ this._unpatch(moduleExports);+ }+ }+ );+ return [module];+ }++ public manualPatch(qdrant: any): void {+ this._patch(qdrant);+ }++ protected _patch(moduleExports: any) {+ try {+ const QdrantClient = moduleExports.QdrantClient;+ if (!QdrantClient?.prototype) return;++ const patchMap: Array<[string, (tracer: any) => any]> = [+ ['search', QdrantWrapper._patchSearch.bind(QdrantWrapper)],+ ['upsert', QdrantWrapper._patchUpsert.bind(QdrantWrapper)],+ ['delete', QdrantWrapper._patchDelete.bind(QdrantWrapper)],+ ['retrieve', QdrantWrapper._patchRetrieve.bind(QdrantWrapper)],+ ['scroll', QdrantWrapper._patchScroll.bind(QdrantWrapper)],+ ];++ for (const [method, patchFn] of patchMap) {+ if (typeof QdrantClient.prototype[method] === 'function') {+ if (isWrapped(QdrantClient.prototype[method])) {+ this._unwrap(QdrantClient.prototype, method);+ }+ this._wrap(QdrantClient.prototype, method, patchFn(this.tracer));+ }+ }+ } catch (e) {+ console.error('Error in Qdrant _patch method:', e);+ }+ }++ protected _unpatch(moduleExports: any) {+ try {+ const QdrantClient = moduleExports.QdrantClient;+ if (!QdrantClient?.prototype) return;+ for (const method of ['search', 'upsert', 'delete', 'retrieve', 'scroll']) {+ if (typeof QdrantClient.prototype[method] === 'function') {+ this._unwrap(QdrantClient.prototype, method);+ }+ }+ } catch { /* ignore */ }+ }+}diff --git a/sdk/typescript/src/instrumentation/qdrant/wrapper.ts b/sdk/typescript/src/instrumentation/qdrant/wrapper.tsnew file mode 100644index 00000000..3edb283a--- /dev/null+++ b/sdk/typescript/src/instrumentation/qdrant/wrapper.ts@@ -0,0 +1,236 @@+import { SpanKind, Tracer, context, trace } from '@opentelemetry/api';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';+import BaseWrapper from '../base-wrapper';++class QdrantWrapper extends BaseWrapper {+ static dbSystem = SemanticConvention.DB_SYSTEM_QDRANT;+ static serverAddress = 'localhost';+ static serverPort = 6333;++ static _setCommonAttributes(span: any, dbOperation: string, collectionName: string) {+ const applicationName = OpenlitConfig.applicationName || '';+ const environment = OpenlitConfig.environment || '';++ span.setAttribute(SemanticConvention.DB_SYSTEM_NAME, QdrantWrapper.dbSystem);+ span.setAttribute(SemanticConvention.DB_OPERATION_NAME, dbOperation);+ span.setAttribute(SemanticConvention.DB_COLLECTION_NAME, collectionName);+ span.setAttribute(SemanticConvention.SERVER_ADDRESS, QdrantWrapper.serverAddress);+ span.setAttribute(SemanticConvention.SERVER_PORT, QdrantWrapper.serverPort);+ span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);+ span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);+ }++ static _patchSearch(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_SEARCH;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ // args[0] = collectionName, args[1] = searchParams+ const collectionName: string = typeof args[0] === 'string' ? args[0] : 'unknown';+ const params = args[1] || {};+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ QdrantWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);+ span.setAttribute(SemanticConvention.DB_VECTOR_QUERY_TOP_K, params.limit || 10);++ if (params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.filter));+ }+ if (params.with_payload !== undefined) {+ span.setAttribute(SemanticConvention.DB_WITH_PAYLOAD, String(params.with_payload));+ }++ const resultCount = Array.isArray(response) ? response.length : 0;+ span.setAttribute(SemanticConvention.DB_N_RESULTS, resultCount);++ if (OpenlitConfig.traceContent && params.vector) {+ const vectorPreview = Array.isArray(params.vector)+ ? JSON.stringify(params.vector.slice(0, 10))+ : String(params.vector);+ span.setAttribute(SemanticConvention.DB_QUERY_TEXT, vectorPreview);+ }++ span.setAttribute(+ SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} limit=${params.limit || 10} filtered=${params.filter ? 'true' : 'false'}`+ );++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchUpsert(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_UPSERT;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const collectionName: string = typeof args[0] === 'string' ? args[0] : 'unknown';+ const params = args[1] || {};+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;+ const points = params.points || [];++ QdrantWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);+ span.setAttribute(SemanticConvention.DB_VECTOR_COUNT, points.length);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} points=${points.length}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchDelete(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_DELETE;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const collectionName: string = typeof args[0] === 'string' ? args[0] : 'unknown';+ const params = args[1] || {};+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ QdrantWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ const points = params.points || [];+ if (points.length > 0) {+ span.setAttribute(SemanticConvention.DB_ID_COUNT, points.length);+ }+ if (params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.filter));+ }+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} points=${points.length}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchRetrieve(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_GET;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const collectionName: string = typeof args[0] === 'string' ? args[0] : 'unknown';+ const params = args[1] || {};+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ QdrantWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);++ const ids = Array.isArray(params.ids) ? params.ids : [];+ span.setAttribute(SemanticConvention.DB_ID_COUNT, ids.length);+ const resultCount = Array.isArray(response) ? response.length : 0;+ span.setAttribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, resultCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} ids=${ids.length}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }++ static _patchScroll(tracer: Tracer): any {+ const dbOperation = SemanticConvention.DB_OPERATION_GET;+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const collectionName: string = typeof args[0] === 'string' ? args[0] : 'unknown';+ const params = args[1] || {};+ const spanName = `${dbOperation} ${collectionName}`;+ const span = tracer.startSpan(spanName, { kind: SpanKind.CLIENT });+ const startTime = Date.now();++ return context.with(trace.setSpan(context.active(), span), async () => {+ try {+ const response = await originalMethod.apply(this, args);+ const duration = (Date.now() - startTime) / 1000;++ QdrantWrapper._setCommonAttributes(span, dbOperation, collectionName);+ span.setAttribute(SemanticConvention.DB_CLIENT_OPERATION_DURATION, duration);+ span.setAttribute(SemanticConvention.DB_QUERY_LIMIT, params.limit || 10);++ if (params.filter) {+ span.setAttribute(SemanticConvention.DB_FILTER, JSON.stringify(params.filter));+ }++ const resultCount = response?.points?.length || 0;+ span.setAttribute(SemanticConvention.DB_RESPONSE_RETURNED_ROWS, resultCount);+ span.setAttribute(SemanticConvention.DB_QUERY_SUMMARY,+ `${dbOperation} ${collectionName} limit=${params.limit || 10}`);++ span.setStatus({ code: 1 });+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ }+ });+ };+ };+ }+}++export default QdrantWrapper;diff --git a/sdk/typescript/src/instrumentation/replicate/index.ts b/sdk/typescript/src/instrumentation/replicate/index.tsnew file mode 100644index 00000000..d56f0fe3--- /dev/null+++ b/sdk/typescript/src/instrumentation/replicate/index.ts@@ -0,0 +1,66 @@+import {+ InstrumentationBase,+ InstrumentationModuleDefinition,+ InstrumentationNodeModuleDefinition,+ isWrapped,+} from '@opentelemetry/instrumentation';+import { InstrumentationConfig } from '@opentelemetry/instrumentation';+import { INSTRUMENTATION_PREFIX } from '../../constant';+import ReplicateWrapper from './wrapper';++export interface ReplicateInstrumentationConfig extends InstrumentationConfig {}++export default class OpenlitReplicateInstrumentation extends InstrumentationBase {+ constructor(config: ReplicateInstrumentationConfig = {}) {+ super(`${INSTRUMENTATION_PREFIX}/instrumentation-replicate`, '1.0.0', config);+ }++ protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {+ const module = new InstrumentationNodeModuleDefinition(+ 'replicate',+ ['>=0.25.0'],+ (moduleExports) => {+ this._patch(moduleExports);+ return moduleExports;+ },+ (moduleExports) => {+ if (moduleExports !== undefined) {+ this._unpatch(moduleExports);+ }+ }+ );+ return [module];+ }++ public manualPatch(replicate: any): void {+ this._patch(replicate);+ }++ protected _patch(moduleExports: any) {+ try {+ // Replicate can be default export (ESM) or module itself (CJS)+ const ReplicateClass = moduleExports.default ?? moduleExports.Replicate ?? moduleExports;+ const proto = ReplicateClass?.prototype;+ if (!proto) return;++ if (typeof proto.run === 'function') {+ if (isWrapped(proto.run)) {+ this._unwrap(proto, 'run');+ }+ this._wrap(proto, 'run', ReplicateWrapper._patchRun(this.tracer));+ }+ } catch (e) {+ console.error('Error in Replicate _patch method:', e);+ }+ }++ protected _unpatch(moduleExports: any) {+ try {+ const ReplicateClass = moduleExports.default ?? moduleExports.Replicate ?? moduleExports;+ const proto = ReplicateClass?.prototype;+ if (proto && typeof proto.run === 'function') {+ this._unwrap(proto, 'run');+ }+ } catch { /* ignore */ }+ }+}diff --git a/sdk/typescript/src/instrumentation/replicate/wrapper.ts b/sdk/typescript/src/instrumentation/replicate/wrapper.tsnew file mode 100644index 00000000..65637472--- /dev/null+++ b/sdk/typescript/src/instrumentation/replicate/wrapper.ts@@ -0,0 +1,116 @@+import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';+import OpenlitConfig from '../../config';+import OpenLitHelper from '../../helpers';+import SemanticConvention from '../../semantic-convention';+import BaseWrapper from '../base-wrapper';++class ReplicateWrapper extends BaseWrapper {+ static aiSystem = SemanticConvention.GEN_AI_SYSTEM_REPLICATE;+ static serverAddress = 'api.replicate.com';+ static serverPort = 443;++ static _patchRun(tracer: Tracer): any {+ const genAIEndpoint = 'replicate.run';+ return (originalMethod: (...args: any[]) => any) => {+ return async function (this: any, ...args: any[]) {+ const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });+ return context+ .with(trace.setSpan(context.active(), span), async () => {+ return originalMethod.apply(this, args);+ })+ .then((response: any) => ReplicateWrapper._run({ args, genAIEndpoint, response, span }))+ .catch((e: any) => {+ OpenLitHelper.handleException(span, e);+ span.end();+ throw e;+ });+ };+ };+ }++ static async _run({+ args,+ genAIEndpoint,+ response,+ span,+ }: {+ args: any[];+ genAIEndpoint: string;+ response: any;+ span: Span;+ }): Promise<any> {+ let metricParams;+ try {+ const traceContent = OpenlitConfig.traceContent;++ // args[0] is the model identifier: "owner/model" or "owner/model:version"+ // args[1] is { input: { prompt, ... }, ... }+ const identifier = typeof args[0] === 'string' ? args[0] : '';+ const options = args[1] || {};+ const input = options.input || {};+ const prompt: string = input.prompt || '';++ // Derive a clean model name from the identifier (strip version hash)+ const model = identifier.split(':')[0] || identifier;++ span.setAttribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION);+ span.setAttribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, false);++ if (traceContent && prompt) {+ span.setAttribute(SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT, prompt);+ }++ // Determine output type and content+ let outputText = '';+ let outputType = SemanticConvention.GEN_AI_OUTPUT_TYPE_TEXT;++ if (typeof response === 'string') {+ outputText = response;+ } else if (Array.isArray(response)) {+ outputText = response.join('');+ } else if (response && typeof response === 'object') {+ outputType = SemanticConvention.GEN_AI_OUTPUT_TYPE_JSON;+ outputText = JSON.stringify(response);+ }++ span.setAttribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, outputType);++ const promptTokens = OpenLitHelper.generalTokens(prompt) ?? 0;+ const completionTokens = OpenLitHelper.generalTokens(outputText) ?? 0;++ const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);+ const cost = OpenLitHelper.getChatModelCost(model, pricingInfo, promptTokens, completionTokens);++ ReplicateWrapper.setBaseSpanAttributes(span, {+ genAIEndpoint,+ model,+ cost,+ aiSystem: ReplicateWrapper.aiSystem,+ serverAddress: ReplicateWrapper.serverAddress,+ serverPort: ReplicateWrapper.serverPort,+ });++ span.setAttribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, promptTokens);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, completionTokens);+ span.setAttribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS, promptTokens + completionTokens);+ span.setAttribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, promptTokens + completionTokens);++ if (traceContent && outputText) {+ span.setAttribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT, outputText);+ }++ metricParams = { genAIEndpoint, model, cost, aiSystem: ReplicateWrapper.aiSystem };+ return response;+ } catch (e: any) {+ OpenLitHelper.handleException(span, e);+ throw e;+ } finally {+ span.end();+ if (metricParams) {+ BaseWrapper.recordMetrics(span, metricParams);+ }+ }+ }+}++export default ReplicateWrapper;diff --git a/sdk/typescript/src/instrumentation/together/wrapper.ts b/sdk/typescript/src/instrumentation/together/wrapper.tsindex 70094f61..cae1ca7d 100644--- a/sdk/typescript/src/instrumentation/together/wrapper.ts+++ b/sdk/typescript/src/instrumentation/together/wrapper.ts@@ -345,7 +345,9 @@ class TogetherWrapper extends BaseWrapper {span.setAttribute(SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, toolArgs);}if (toolTypes.length > 0) {- span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypes.join(', '));+ const toolTypesStr = toolTypes.join(', ');+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE, toolTypesStr);+ span.setAttribute(SemanticConvention.GEN_AI_TOOL_TYPE_OTEL, toolTypesStr);}}diff --git a/sdk/typescript/src/semantic-convention.ts b/sdk/typescript/src/semantic-convention.tsindex a5526cab..0b346ee3 100644--- a/sdk/typescript/src/semantic-convention.ts+++ b/sdk/typescript/src/semantic-convention.ts@@ -1,33 +1,85 @@+/**+ * Semantic conventions aligned with OpenTelemetry Gen AI spec and Python SDK.+ * Old keys are kept for backward compatibility; new OTel-aligned keys are added with _OTEL suffix.+ */export default class SemanticConvention {// Unstable SemConv- static ATTR_DEPLOYMENT_ENVIRONMENT = 'deployment.environment'- // GenAI General- static GEN_AI_ENDPOINT = 'gen_ai.endpoint';+ static ATTR_DEPLOYMENT_ENVIRONMENT = 'deployment.environment';++ // ----- GenAI General (legacy keys kept for backward compatibility) -----static GEN_AI_PROVIDER_NAME = 'gen_ai.system';+ /** OTel standard: use for new code / future compatibility */+ static GEN_AI_PROVIDER_NAME_OTEL = 'gen_ai.provider.name';++ // ----- OTel Gen AI & Server/Error (new keys; legacy below unchanged) -----+ static GEN_AI_OPERATION = 'gen_ai.operation.name';+ static GEN_AI_OUTPUT_TYPE = 'gen_ai.output.type';+ static GEN_AI_REQUEST_MODEL = 'gen_ai.request.model';+ static GEN_AI_REQUEST_SEED = 'gen_ai.request.seed';+ static GEN_AI_REQUEST_CHOICE_COUNT = 'gen_ai.request.choice.count';+ static GEN_AI_REQUEST_ENCODING_FORMATS = 'gen_ai.request.encoding_formats';+ static GEN_AI_REQUEST_FREQUENCY_PENALTY = 'gen_ai.request.frequency_penalty';+ static GEN_AI_REQUEST_MAX_TOKENS = 'gen_ai.request.max_tokens';+ static GEN_AI_REQUEST_PRESENCE_PENALTY = 'gen_ai.request.presence_penalty';+ static GEN_AI_REQUEST_STOP_SEQUENCES = 'gen_ai.request.stop_sequences';+ static GEN_AI_REQUEST_TEMPERATURE = 'gen_ai.request.temperature';+ static GEN_AI_REQUEST_TOP_K = 'gen_ai.request.top_k';+ static GEN_AI_REQUEST_TOP_P = 'gen_ai.request.top_p';+ static GEN_AI_CONVERSATION_ID = 'gen_ai.conversation.id';+ static GEN_AI_RESPONSE_FINISH_REASON = 'gen_ai.response.finish_reasons';+ static GEN_AI_RESPONSE_ID = 'gen_ai.response.id';+ static GEN_AI_RESPONSE_MODEL = 'gen_ai.response.model';+ static GEN_AI_INPUT_MESSAGES = 'gen_ai.input.messages';+ static GEN_AI_OUTPUT_MESSAGES = 'gen_ai.output.messages';+ /** Legacy */+ static GEN_AI_SYSTEM_INSTRUCTIONS = 'gen_ai.system.instructions';+ /** OTel standard */+ static GEN_AI_SYSTEM_INSTRUCTIONS_OTEL = 'gen_ai.system_instructions';+ static GEN_AI_TOOL_DEFINITIONS = 'gen_ai.tool.definitions';+ static GEN_AI_EMBEDDINGS_DIMENSION_COUNT = 'gen_ai.embeddings.dimension.count';+ static GEN_AI_TOKEN_TYPE = 'gen_ai.token.type';+ static GEN_AI_TOKEN_TYPE_INPUT = 'input';+ static GEN_AI_TOKEN_TYPE_OUTPUT = 'output';+ static GEN_AI_TOKEN_TYPE_REASONING = 'reasoning';+ static GEN_AI_CLIENT_OPERATION_DURATION = 'gen_ai.client.operation.duration';+ static GEN_AI_CLIENT_OPERATION_TIME_TO_FIRST_CHUNK = 'gen_ai.client.operation.time_to_first_chunk';+ static GEN_AI_CLIENT_OPERATION_TIME_PER_OUTPUT_CHUNK = 'gen_ai.client.operation.time_per_output_chunk';+ static GEN_AI_CLIENT_TOKEN_USAGE = 'gen_ai.client.token.usage';+ static GEN_AI_SERVER_REQUEST_DURATION = 'gen_ai.server.request.duration';+ static GEN_AI_SERVER_TBT = 'gen_ai.server.time_per_output_token';+ static GEN_AI_SERVER_TTFT = 'gen_ai.server.time_to_first_token';+ static SERVER_ADDRESS = 'server.address';+ static SERVER_PORT = 'server.port';+ static ERROR_TYPE = 'error.type';+ static ERROR_TYPE_UNAVAILABLE = 'unavailable';+ static ERROR_TYPE_AUTHENTICATION = 'authentication';+ static ERROR_TYPE_TIMEOUT = 'timeout';+ static ERROR_TYPE_RATE_LIMITED = 'rate_limited';+ static ERROR_TYPE_PERMISSION = 'permission';+ static ERROR_TYPE_NOT_FOUND = 'not_found';+ static ERROR_TYPE_INVALID_REQUEST = 'invalid_request';+ static ERROR_TYPE_SERVER_ERROR = 'server_error';++ // GenAI event names (OTel)+ static GEN_AI_USER_MESSAGE = 'gen_ai.user.message';+ static GEN_AI_SYSTEM_MESSAGE = 'gen_ai.system.message';+ static GEN_AI_ASSISTANT_MESSAGE = 'gen_ai.assistant.message';+ static GEN_AI_TOOL_MESSAGE = 'gen_ai.tools.message';+ static GEN_AI_CHOICE = 'gen_ai.choice';++ // ----- GenAI General (OpenLIT + OTel) -----+ static GEN_AI_ENDPOINT = 'gen_ai.endpoint';static GEN_AI_ENVIRONMENT = 'gen_ai.environment';static GEN_AI_APPLICATION_NAME = 'gen_ai.application_name';- static GEN_AI_OPERATION = 'gen_ai.operation.name';static GEN_AI_HUB_OWNER = 'gen_ai.hub.owner';static GEN_AI_HUB_REPO = 'gen_ai.hub.repo';static GEN_AI_RETRIEVAL_SOURCE = 'gen_ai.retrieval.source';static GEN_AI_REQUESTS = 'gen_ai.total.requests';static GEN_AI_SDK_VERSION = 'gen_ai.sdk.version';- static GEN_AI_OUTPUT_TYPE = 'gen_ai.output.type';-- // GenAI Request- static GEN_AI_REQUEST_MODEL = 'gen_ai.request.model';- static GEN_AI_REQUEST_TEMPERATURE = 'gen_ai.request.temperature';- static GEN_AI_REQUEST_TOP_P = 'gen_ai.request.top_p';- static GEN_AI_REQUEST_TOP_K = 'gen_ai.request.top_k';- static GEN_AI_REQUEST_MAX_TOKENS = 'gen_ai.request.max_tokens';+ // GenAI Request (extended / OpenLIT)static GEN_AI_REQUEST_IS_STREAM = 'gen_ai.request.is_stream';static GEN_AI_REQUEST_USER = 'gen_ai.request.user';- static GEN_AI_REQUEST_SEED = 'gen_ai.request.seed';- static GEN_AI_REQUEST_FREQUENCY_PENALTY = 'gen_ai.request.frequency_penalty';- static GEN_AI_REQUEST_PRESENCE_PENALTY = 'gen_ai.request.presence_penalty';- static GEN_AI_REQUEST_STOP_SEQUENCES = 'gen_ai.request.stop_sequences';- static GEN_AI_REQUEST_ENCODING_FORMATS = 'gen_ai.request.encoding_formats';static GEN_AI_REQUEST_EMBEDDING_DIMENSION = 'gen_ai.request.embedding_dimension';static GEN_AI_REQUEST_TOOL_CHOICE = 'gen_ai.request.tool_choice';static GEN_AI_REQUEST_AUDIO_VOICE = 'gen_ai.request.audio_voice';@@ -44,6 +96,11 @@ export default class SemanticConvention {static GEN_AI_REQUEST_IMAGE_SIZE = 'gen_ai.request.image_size';static GEN_AI_REQUEST_IMAGE_QUALITY = 'gen_ai.request.image_quality';static GEN_AI_REQUEST_IMAGE_STYLE = 'gen_ai.request.image_style';+ static GEN_AI_REQUEST_SAFE_PROMPT = 'gen_ai.request.safe_prompt';+ static GEN_AI_REQUEST_REASONING_EFFORT = 'gen_ai.request.reasoning_effort';++ /** Legacy key for reading duration from span attributes */+ static GEN_AI_DURATION_LEGACY = 'gen_ai.duration';// GenAI Usagestatic GEN_AI_USAGE_INPUT_TOKENS = 'gen_ai.usage.input_tokens';@@ -61,39 +118,53 @@ export default class SemanticConvention {static GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS = 'gen_ai.usage.cache_creation.input_tokens';static GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS = 'gen_ai.usage.cache_read.input_tokens';- // GenAI Response- static GEN_AI_RESPONSE_ID = 'gen_ai.response.id';- static GEN_AI_RESPONSE_MODEL = 'gen_ai.response.model';- static GEN_AI_RESPONSE_FINISH_REASON = 'gen_ai.response.finish_reasons';+ // GenAI Response (extended)static GEN_AI_RESPONSE_IMAGE = 'gen_ai.response.image';static GEN_AI_RESPONSE_IMAGE_SIZE = 'gen_ai.request.image_size';static GEN_AI_RESPONSE_IMAGE_QUALITY = 'gen_ai.request.image_quality';static GEN_AI_RESPONSE_IMAGE_STYLE = 'gen_ai.request.image_style';-- // OpenAI-specific attributesstatic GEN_AI_REQUEST_SERVICE_TIER = 'gen_ai.request.service_tier';static GEN_AI_RESPONSE_SERVICE_TIER = 'gen_ai.response.service_tier';static GEN_AI_RESPONSE_SYSTEM_FINGERPRINT = 'gen_ai.response.system_fingerprint';// GenAI Content- static GEN_AI_INPUT_MESSAGES = 'gen_ai.input.messages';- static GEN_AI_OUTPUT_MESSAGES = 'gen_ai.output.messages';static GEN_AI_CONTENT_PROMPT_EVENT = 'gen_ai.content.prompt';static GEN_AI_CONTENT_COMPLETION_EVENT = 'gen_ai.content.completion';- static GEN_AI_SYSTEM_INSTRUCTIONS = 'gen_ai.system.instructions';static GEN_AI_CONTENT_REVISED_PROMPT = 'gen_ai.content.revised_prompt';-- // Tool attributes+ static GEN_AI_CONTENT_REASONING = 'gen_ai.content.reasoning';++ // Tool attributes (legacy: gen_ai.tool.call.type; OTel: gen_ai.tool.type)static GEN_AI_TOOL_NAME = 'gen_ai.tool.name';static GEN_AI_TOOL_TYPE = 'gen_ai.tool.call.type';+ /** OTel standard */+ static GEN_AI_TOOL_TYPE_OTEL = 'gen_ai.tool.type';static GEN_AI_TOOL_DESCRIPTION = 'gen_ai.tool.description';static GEN_AI_TOOL_DEFINITION = 'gen_ai.tool.definition';static GEN_AI_TOOL_CALL_ID = 'gen_ai.tool.call.id';static GEN_AI_TOOL_CALL_ARGUMENTS = 'gen_ai.tool.call.arguments';static GEN_AI_TOOL_CALL_RESULT = 'gen_ai.tool.call.result';+ static GEN_AI_TOOL_INPUT = 'gen_ai.tool.input';+ static GEN_AI_TOOL_OUTPUT = 'gen_ai.tool.output';+ static GEN_AI_TOOL_ARGS = 'gen_ai.tool.args';+ // Retrieval (framework / RAG)+ static GEN_AI_RETRIEVAL_QUERY = 'gen_ai.retrieval.query';+ static GEN_AI_RETRIEVAL_DOCUMENTS = 'gen_ai.retrieval.documents';+ static GEN_AI_RETRIEVAL_DOCUMENT_COUNT = 'gen_ai.retrieval.document_count';- static GEN_AI_TOKEN_TYPE = 'gen_ai.token.type';+ // Workflow / framework+ static GEN_AI_WORKFLOW_INPUT = 'gen_ai.workflow.input';+ static GEN_AI_WORKFLOW_OUTPUT = 'gen_ai.workflow.output';+ static GEN_AI_WORKFLOW_TYPE = 'gen_ai.workflow.type';+ static GEN_AI_FRAMEWORK_ERROR_CLASS = 'gen_ai.framework.error.class';+ static GEN_AI_FRAMEWORK_ERROR_TYPE = 'gen_ai.framework.error.type';+ static GEN_AI_FRAMEWORK_ERROR_MESSAGE = 'gen_ai.framework.error.message';+ static GEN_AI_SERIALIZED_NAME = 'gen_ai.serialized.name';+ static GEN_AI_SERIALIZED_SIGNATURE = 'gen_ai.serialized.signature';+ static GEN_AI_SERIALIZED_DOC = 'gen_ai.serialized.doc';+ static GEN_AI_SERIALIZED_MODULE = 'gen_ai.serialized.module';+ static GEN_AI_REQUEST_PROVIDER = 'gen_ai.request.provider';+ static GEN_AI_DATA_SOURCES = 'gen_ai.data_source_count';static GEN_AI_OPERATION_TYPE_TEXT_COMPLETION = 'text_completion';static GEN_AI_OPERATION_TYPE_CHAT = 'chat';@@ -111,6 +182,7 @@ export default class SemanticConvention {static GEN_AI_OUTPUT_TYPE_SPEECH = 'speech';static GEN_AI_SYSTEM_HUGGING_FACE = 'huggingface';+ static GEN_AI_SYSTEM_REPLICATE = 'replicate';static GEN_AI_SYSTEM_OPENAI = 'openai';static GEN_AI_SYSTEM_AZURE_OPENAI = 'az.ai.openai';static GEN_AI_SYSTEM_ANTHROPIC = 'anthropic';@@ -128,17 +200,20 @@ export default class SemanticConvention {static DB_SYSTEM_NAME = 'db.system.name';static DB_SYSTEM_CHROMA = 'chroma';static DB_SYSTEM_PINECONE = 'pinecone';+ static DB_SYSTEM_QDRANT = 'qdrant';+ static DB_SYSTEM_MILVUS = 'milvus';static DB_COLLECTION_NAME = 'db.collection.name';static DB_OPERATION = 'db.operation';static DB_OPERATION_NAME = 'db.operation.name';static DB_OPERATION_CREATE_INDEX = 'create_index';+ static DB_OPERATION_INSERT = 'INSERT';static DB_OPERATION_QUERY = 'QUERY';static DB_OPERATION_DELETE = 'DELETE';static DB_OPERATION_UPDATE = 'UPDATE';static DB_OPERATION_UPSERT = 'UPSERT';- static DB_OPERATION_GET = 'get';- static DB_OPERATION_ADD = 'add';- static DB_OPERATION_PEEK = 'peek';+ static DB_OPERATION_GET = 'GET';+ static DB_OPERATION_ADD = 'ADD';+ static DB_OPERATION_PEEK = 'PEEK';static DB_OPERATION_SEARCH = 'SEARCH';static DB_OPERATION_FETCH = 'FETCH';static DB_ID_COUNT = 'db.ids_count';@@ -164,17 +239,19 @@ export default class SemanticConvention {static DB_UPDATE_METADATA = 'db.update.metadata';static DB_UPDATE_VALUES = 'db.update.values';static DB_UPDATE_ID = 'db.update.id';- static GEN_AI_CLIENT_OPERATION_DURATION = 'gen_ai.client.operation.duration';- static GEN_AI_CLIENT_OPERATION_TIME_TO_FIRST_CHUNK = 'gen_ai.client.operation.time_to_first_chunk';- static GEN_AI_CLIENT_OPERATION_TIME_PER_OUTPUT_CHUNK = 'gen_ai.client.operation.time_per_output_chunk';- static GEN_AI_SERVER_REQUEST_DURATION = 'gen_ai.server.request.duration';- static GEN_AI_CLIENT_TOKEN_USAGE = 'gen_ai.client.token.usage';- static GEN_AI_SERVER_TBT = 'gen_ai.server.time_per_output_token';- static GEN_AI_SERVER_TTFT = 'gen_ai.server.time_to_first_token';static DB_CLIENT_OPERATION_DURATION = 'db.client.operation.duration';-- // Server attributes- static SERVER_ADDRESS = 'server.address';- static SERVER_PORT = 'server.port';- static ERROR_TYPE = 'error.type';+ // Vector DB extras (aligned with Python SDK / OTel)+ static DB_QUERY_PARAMETER = 'db.query.parameter';+ static DB_SDK_VERSION = 'db.sdk.version';+ static DB_OPERATION_ID = 'db.operation.id';+ static DB_OPERATION_STATUS = 'db.operation.status';+ static DB_OPERATION_COST = 'db.operation.cost';+ static DB_INDEX_NAME_ALT = 'db.index.name';+ static DB_COLLECTION_DIMENSION = 'db.collection.dimension';+ static DB_VECTOR_QUERY_FILTER = 'db.vector.query.filter';+ static DB_DELETE_ID = 'db.delete.id';+ static DB_METADATA = 'db.metadata';+ static DB_PAYLOAD_COUNT = 'db.payload_count';+ static DB_WITH_PAYLOAD = 'db.with_payload';+ static DB_OUTPUT_FIELDS = 'db.output_fields';}diff --git a/sdk/typescript/src/types.ts b/sdk/typescript/src/types.tsindex a918b354..ba1fd4e0 100644--- a/sdk/typescript/src/types.ts+++ b/sdk/typescript/src/types.ts@@ -3,7 +3,7 @@ import { Resource } from '@opentelemetry/resources';import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';import { metrics } from '@opentelemetry/api';-export type InstrumentationType = 'openai' | 'anthropic' | 'cohere' | 'groq' | 'mistral' | 'google-ai' | 'together' | 'ollama' | 'vercel-ai' | 'langchain' | 'pinecone' | 'bedrock' | 'llamaindex';+export type InstrumentationType = 'openai' | 'anthropic' | 'cohere' | 'groq' | 'mistral' | 'google-ai' | 'together' | 'ollama' | 'vercel-ai' | 'langchain' | 'pinecone' | 'bedrock' | 'llamaindex' | 'huggingface' | 'replicate' | 'chroma' | 'qdrant' | 'milvus';export type OpenlitInstrumentations = Partial<Record<InstrumentationType, any>>;diff --git a/sdk/typescript/tsconfig.json b/sdk/typescript/tsconfig.jsonindex 8af3fc88..9e144631 100644--- a/sdk/typescript/tsconfig.json+++ b/sdk/typescript/tsconfig.json@@ -1,6 +1,7 @@{"compilerOptions": {"target": "ES2020",+ "resolveJsonModule": true,"module": "CommonJS","outDir": "./dist","strict": true,diff --git a/sdk/typescript/tsconfig.tsbuildinfo b/sdk/typescript/tsconfig.tsbuildinfoindex 2d140d5d..0ab6ed92 100644--- a/sdk/typescript/tsconfig.tsbuildinfo+++ b/sdk/typescript/tsconfig.tsbuildinfo@@ -1 +1 @@-{"root":["./src/config.ts","./src/constant.ts","./src/helpers.ts","./src/index.ts","./src/prompt-hub.ts","./src/semantic-convention.ts","./src/types.ts","./src/evals/all.ts","./src/evals/base.ts","./src/evals/bias.ts","./src/evals/hallucination.ts","./src/evals/index.ts","./src/evals/metrics.ts","./src/evals/toxicity.ts","./src/evals/types.ts","./src/evals/utils.ts","./src/evals/__tests__/anthropic.test.ts","./src/evals/__tests__/base.test.ts","./src/evals/__tests__/core.test.ts","./src/evals/__tests__/metrics.test.ts","./src/evals/__tests__/openai.test.ts","./src/evals/__tests__/providers.test.ts","./src/evals/__tests__/utils.test.ts","./src/evals/llm/anthropic.ts","./src/evals/llm/openai.ts","./src/evals/llm/providers.ts","./src/features/base.ts","./src/features/prompt-hub.ts","./src/features/vault.ts","./src/guard/all.ts","./src/guard/base.ts","./src/guard/index.ts","./src/guard/prompt-injection.ts","./src/guard/sensitive-topic.ts","./src/guard/topic-restriction.ts","./src/guard/types.ts","./src/guard/utils.ts","./src/guard/__tests__/gaurd.test.ts","./src/guard/__tests__/utils.test.ts","./src/instrumentation/base-wrapper.ts","./src/instrumentation/index.ts","./src/instrumentation/__tests__/anthropic-wrapper.test.ts","./src/instrumentation/__tests__/base-wrapper.test.ts","./src/instrumentation/__tests__/cohere-wrapper.test.ts","./src/instrumentation/__tests__/google-ai-trace-comparison.test.ts","./src/instrumentation/__tests__/groq-trace-comparison.test.ts","./src/instrumentation/__tests__/mistral-trace-comparison.test.ts","./src/instrumentation/__tests__/openai-wrapper.test.ts","./src/instrumentation/__tests__/together-trace-comparison.test.ts","./src/instrumentation/__tests__/trace-comparison-utils.ts","./src/instrumentation/anthropic/index.ts","./src/instrumentation/anthropic/wrapper.ts","./src/instrumentation/bedrock/index.ts","./src/instrumentation/bedrock/wrapper.ts","./src/instrumentation/cohere/index.ts","./src/instrumentation/cohere/wrapper.ts","./src/instrumentation/google-ai/index.ts","./src/instrumentation/google-ai/wrapper.ts","./src/instrumentation/groq/index.ts","./src/instrumentation/groq/wrapper.ts","./src/instrumentation/langchain/index.ts","./src/instrumentation/langchain/wrapper.ts","./src/instrumentation/llamaindex/index.ts","./src/instrumentation/llamaindex/wrapper.ts","./src/instrumentation/mistral/index.ts","./src/instrumentation/mistral/wrapper.ts","./src/instrumentation/ollama/index.ts","./src/instrumentation/ollama/wrapper.ts","./src/instrumentation/openai/index.ts","./src/instrumentation/openai/wrapper.ts","./src/instrumentation/pinecone/index.ts","./src/instrumentation/pinecone/wrapper.ts","./src/instrumentation/together/index.ts","./src/instrumentation/together/wrapper.ts","./src/instrumentation/vercel-ai/index.ts","./src/instrumentation/vercel-ai/wrapper.ts","./src/llm/anthropic.ts","./src/llm/index.ts","./src/llm/openai.ts","./src/llm/providers.ts","./src/otel/metrics.ts","./src/otel/tracing.ts","./src/otel/__tests__/metrics.test.ts"],"version":"5.8.3"}\ No newline at end of file+{"root":["./src/config.ts","./src/constant.ts","./src/helpers.ts","./src/index.ts","./src/prompt-hub.ts","./src/semantic-convention.ts","./src/types.ts","./src/evals/all.ts","./src/evals/base.ts","./src/evals/bias.ts","./src/evals/hallucination.ts","./src/evals/index.ts","./src/evals/metrics.ts","./src/evals/toxicity.ts","./src/evals/types.ts","./src/evals/utils.ts","./src/evals/__tests__/anthropic.test.ts","./src/evals/__tests__/base.test.ts","./src/evals/__tests__/core.test.ts","./src/evals/__tests__/metrics.test.ts","./src/evals/__tests__/openai.test.ts","./src/evals/__tests__/providers.test.ts","./src/evals/__tests__/utils.test.ts","./src/evals/llm/anthropic.ts","./src/evals/llm/openai.ts","./src/evals/llm/providers.ts","./src/features/base.ts","./src/features/prompt-hub.ts","./src/features/vault.ts","./src/guard/all.ts","./src/guard/base.ts","./src/guard/index.ts","./src/guard/prompt-injection.ts","./src/guard/sensitive-topic.ts","./src/guard/topic-restriction.ts","./src/guard/types.ts","./src/guard/utils.ts","./src/guard/__tests__/gaurd.test.ts","./src/guard/__tests__/utils.test.ts","./src/instrumentation/base-wrapper.ts","./src/instrumentation/index.ts","./src/instrumentation/__tests__/anthropic-wrapper.test.ts","./src/instrumentation/__tests__/base-wrapper.test.ts","./src/instrumentation/__tests__/chroma-trace-comparison.test.ts","./src/instrumentation/__tests__/cohere-wrapper.test.ts","./src/instrumentation/__tests__/google-ai-trace-comparison.test.ts","./src/instrumentation/__tests__/groq-trace-comparison.test.ts","./src/instrumentation/__tests__/huggingface-trace-comparison.test.ts","./src/instrumentation/__tests__/milvus-trace-comparison.test.ts","./src/instrumentation/__tests__/mistral-trace-comparison.test.ts","./src/instrumentation/__tests__/openai-wrapper.test.ts","./src/instrumentation/__tests__/qdrant-trace-comparison.test.ts","./src/instrumentation/__tests__/replicate-trace-comparison.test.ts","./src/instrumentation/__tests__/together-trace-comparison.test.ts","./src/instrumentation/__tests__/trace-comparison-utils.ts","./src/instrumentation/anthropic/index.ts","./src/instrumentation/anthropic/wrapper.ts","./src/instrumentation/bedrock/index.ts","./src/instrumentation/bedrock/wrapper.ts","./src/instrumentation/chroma/index.ts","./src/instrumentation/chroma/wrapper.ts","./src/instrumentation/cohere/index.ts","./src/instrumentation/cohere/wrapper.ts","./src/instrumentation/google-ai/index.ts","./src/instrumentation/google-ai/wrapper.ts","./src/instrumentation/groq/index.ts","./src/instrumentation/groq/wrapper.ts","./src/instrumentation/huggingface/index.ts","./src/instrumentation/huggingface/wrapper.ts","./src/instrumentation/langchain/index.ts","./src/instrumentation/langchain/wrapper.ts","./src/instrumentation/llamaindex/index.ts","./src/instrumentation/llamaindex/wrapper.ts","./src/instrumentation/milvus/index.ts","./src/instrumentation/milvus/wrapper.ts","./src/instrumentation/mistral/index.ts","./src/instrumentation/mistral/wrapper.ts","./src/instrumentation/ollama/index.ts","./src/instrumentation/ollama/wrapper.ts","./src/instrumentation/openai/index.ts","./src/instrumentation/openai/wrapper.ts","./src/instrumentation/pinecone/index.ts","./src/instrumentation/pinecone/wrapper.ts","./src/instrumentation/qdrant/index.ts","./src/instrumentation/qdrant/wrapper.ts","./src/instrumentation/replicate/index.ts","./src/instrumentation/replicate/wrapper.ts","./src/instrumentation/together/index.ts","./src/instrumentation/together/wrapper.ts","./src/instrumentation/vercel-ai/index.ts","./src/instrumentation/vercel-ai/wrapper.ts","./src/llm/anthropic.ts","./src/llm/index.ts","./src/llm/openai.ts","./src/llm/providers.ts","./src/otel/metrics.ts","./src/otel/tracing.ts","./src/otel/__tests__/metrics.test.ts"],"version":"5.8.3"}\ No newline at end of file