Prism OpenTelemetry

composer require particle-academy/prism-opentelemetry

# Plus an OpenTelemetry SDK and an OTLP exporter — transport of your choice.
composer require open-telemetry/sdk open-telemetry/exporter-otlp

npm install @particle-academy/prism-opentelemetry

# Plus the OpenTelemetry API and an SDK + exporter of your choice, e.g.
npm install @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-proto

pip install prism-ai-opentelemetry

# Plus the OpenTelemetry SDK and an exporter of your choice, e.g.
pip install opentelemetry-sdk opentelemetry-exporter-otlp

// prism-otel.ts
import {
  context,
  trace,
  SpanKind,
  SpanStatusCode,
  type Span as OtelSpan,
  type Tracer as OtelTracer,
} from '@opentelemetry/api';
import type { AttributeValue, Span, StartSpanOptions, Tracer } from '@particle-academy/prism-opentelemetry';

// The subscriber works in epoch nanoseconds; @opentelemetry/api takes epoch milliseconds.
const millis = (nanos?: number): number | undefined =>
  nanos === undefined ? undefined : nanos / 1_000_000;

class PrismSpan implements Span {
  readonly inner: OtelSpan;

  constructor(inner: OtelSpan) {
    this.inner = inner;
  }

  setAttribute(key: string, value: AttributeValue): void {
    this.inner.setAttribute(key, typeof value === 'object' ? [...value] : value);
  }

  setStatus(status: { code: 'ok' | 'error'; message?: string }): void {
    this.inner.setStatus(
      status.code === 'ok'
        ? { code: SpanStatusCode.OK }
        : { code: SpanStatusCode.ERROR, message: status.message },
    );
  }

  recordException(error: unknown): void {
    this.inner.recordException(error instanceof Error ? error : String(error));
  }

  end(endTimeNanos?: number): void {
    this.inner.end(millis(endTimeNanos));
  }
}

export function prismTracer(tracer: OtelTracer): Tracer {
  return {
    startSpan(name: string, options: StartSpanOptions = {}): Span {
      const parent = options.parent instanceof PrismSpan ? options.parent.inner : null;

      // A root span joins whatever span is active in your app (an HTTP request, a job).
      const ctx = parent === null ? context.active() : trace.setSpan(context.active(), parent);

      const span = tracer.startSpan(
        name,
        {
          kind: parent === null || options.kind === 'client' ? SpanKind.CLIENT : SpanKind.INTERNAL,
          startTime: millis(options.startTimeNanos),
        },
        ctx,
      );

      return new PrismSpan(span);
    },
  };
}

# prism_otel.py
from __future__ import annotations

from collections.abc import Sequence

from opentelemetry import trace
from opentelemetry.trace import SpanKind, Status, StatusCode

from prism_opentelemetry import AttributeValue, Span


class PrismSpan:
    def __init__(self, inner: trace.Span) -> None:
        self.inner = inner

    def set_attribute(self, key: str, value: AttributeValue) -> None:
        if isinstance(value, Sequence) and not isinstance(value, str):
            value = list(value)
        self.inner.set_attribute(key, value)

    def set_status(self, code: str, message: str | None = None) -> None:
        if code == "ok":
            self.inner.set_status(Status(StatusCode.OK))
        else:
            self.inner.set_status(Status(StatusCode.ERROR, message))

    def record_exception(self, error: BaseException | None) -> None:
        if error is not None:
            self.inner.record_exception(error)

    def end(self, end_time_nanos: int | None = None) -> None:
        # Both sides use epoch nanoseconds, so the timestamp passes straight through.
        self.inner.end(end_time=end_time_nanos)


class PrismTracer:
    def __init__(self, tracer: trace.Tracer) -> None:
        self._tracer = tracer

    def start_span(
        self, name: str, start_time_nanos: int | None = None, parent: Span | None = None
    ) -> PrismSpan:
        # A root span joins whatever span is active in your app (a request, a job).
        context = (
            trace.set_span_in_context(parent.inner) if isinstance(parent, PrismSpan) else None
        )

        return PrismSpan(
            self._tracer.start_span(
                name,
                context=context,
                kind=SpanKind.CLIENT if context is None else SpanKind.INTERNAL,
                start_time=start_time_nanos,
            )
        )

use Prism\Prism\Facades\Prism;

$response = Prism::text()
    ->using('anthropic', 'claude-sonnet-4-5')
    ->withPrompt('Summarise the incident.')
    ->asText(); // the bridge records Prism's emitted telemetry events

import { trace } from '@opentelemetry/api';
import {
  TelemetrySubscriber,
  advertisedToolDigest,
  type AdvertisedTool,
} from '@particle-academy/prism-opentelemetry';
import { prismTracer } from './prism-otel';

const telemetry = new TelemetrySubscriber(prismTracer(trace.getTracer('prism')));

const searchTool = {
  name: 'search_docs',
  description: 'Search the product documentation.',
  parameters: { type: 'object', properties: { query: { type: 'string' } } },
};

// The tools the model was offered, in the order they were sent.
const tools: AdvertisedTool[] = [
  { ...searchTool, digest: advertisedToolDigest(searchTool) },
];

telemetry.onGenerationStarted(
  { traceId: 'run-42', operation: 'text', provider: 'anthropic', model: 'claude-sonnet-4-5', sessionId: 'conv-7' },
  prompt,
  tools,
);

telemetry.onToolInvoked('run-42', {
  name: 'search_docs',
  callId: 'call_1',
  stepIndex: 0,
  parameters: { query: 'refund policy' },
  result: 'Refunds are issued within 14 days.',
  failed: false,
  error: null,
});

telemetry.onStepCompleted('run-42', 0, 'claude-sonnet-4-5', 'anthropic', {
  promptTokens: 812,
  completionTokens: 64,
  cacheReadInputTokens: 2048,
});

telemetry.onGenerationCompleted('run-42', {
  finishReason: 'stop',
  usage: { promptTokens: 1650, completionTokens: 210, cost: 0.0081 },
  output: responseText,
  rateLimits: [{ name: 'requests', limit: 1000, remaining: 998, resetsAt: new Date(Date.now() + 60_000) }],
});

// Or, when the generation throws:
telemetry.onGenerationFailed('run-43', error);

from datetime import datetime, timedelta, timezone

from opentelemetry import trace
from prism_opentelemetry import (
    AdvertisedTool,
    GenerationContext,
    PendingTool,
    RateLimit,
    TelemetrySubscriber,
    Usage,
    advertised_tool_digest,
)

from prism_otel import PrismTracer

telemetry = TelemetrySubscriber(PrismTracer(trace.get_tracer("prism")))

schema = {"type": "object", "properties": {"query": {"type": "string"}}}
# The tools the model was offered, in the order they were sent.
tools = [
    AdvertisedTool(
        name="search_docs",
        digest=advertised_tool_digest("search_docs", "Search the product documentation.", schema),
        description="Search the product documentation.",
        parameters=schema,
    )
]

telemetry.on_generation_started(
    GenerationContext(
        trace_id="run-42",
        operation="text",
        provider="anthropic",
        model="claude-sonnet-4-5",
        session_id="conv-7",
    ),
    prompt,
    tools,
)

telemetry.on_tool_invoked(
    "run-42",
    PendingTool(
        name="search_docs",
        call_id="call_1",
        step_index=0,
        parameters={"query": "refund policy"},
        result="Refunds are issued within 14 days.",
    ),
)

telemetry.on_step_completed(
    "run-42", 0, "claude-sonnet-4-5", "anthropic",
    Usage(prompt_tokens=812, completion_tokens=64, cache_read_input_tokens=2048),
)

telemetry.on_generation_completed(
    "run-42",
    finish_reason="stop",
    usage=Usage(prompt_tokens=1650, completion_tokens=210, cost=0.0081),
    output=response_text,
    rate_limits=[
        RateLimit(
            name="requests",
            limit=1000,
            remaining=998,
            resets_at=datetime.now(timezone.utc) + timedelta(seconds=60),
        )
    ],
)

# Or, when the generation raises:
telemetry.on_generation_failed("run-43", error)

const telemetry = new TelemetrySubscriber(prismTracer(trace.getTracer('prism')), undefined, {
  captureContent: true,
  maxContentLength: 16_384,
});

telemetry = TelemetrySubscriber(
    PrismTracer(trace.get_tracer("prism")),
    capture_content=True,
    max_content_length=16_384,
)