@heystack/otel 0.13.0 → 0.15.0

package/dist/llm-enrich.js

@@ -8,12 +8,112 @@ export function detectLLMProvider(host) {
         return "openai";
     if (h === "api.anthropic.com")
         return "anthropic";
+    if (h === "api.mistral.ai")
+        return "mistral";
     if (h === "generativelanguage.googleapis.com")
         return "google";
     if (h === "gateway.ai.cloudflare.com" || h.endsWith(".gateway.ai.cloudflare.com"))
         return "cloudflare";
     return null;
 }
+/** Map a gateway path token to a provider. `gemini` → google, `workers-ai` → cloudflare. */
+export function providerFromToken(token) {
+    switch (token.toLowerCase()) {
+        case "openai":
+            return "openai";
+        case "anthropic":
+            return "anthropic";
+        case "google":
+        case "gemini":
+            return "google";
+        case "mistral":
+            return "mistral";
+        case "cloudflare":
+        case "workers-ai":
+            return "cloudflare";
+        default:
+            return null;
+    }
+}
+function hostMatchesSuffix(host, suffix) {
+    const s = suffix.toLowerCase().replace(/^\.+/, "");
+    if (!s)
+        return false;
+    return host === s || host.endsWith("." + s);
+}
+/** Split a path into non-empty segments. */
+function segments(path) {
+    return path.split("/").filter((s) => s.length > 0);
+}
+/**
+ * Resolve the LLM provider for an outbound URL: direct host table first, then
+ * each configured gateway pattern. Returns null when neither matches. Pure and
+ * exception-free (a malformed gateway entry is skipped, never thrown).
+ */
+export function resolveLLMProvider(url, gateways) {
+    const host = url.hostname.toLowerCase();
+    const direct = detectLLMProvider(host);
+    if (direct)
+        return { provider: direct };
+    if (!gateways || gateways.length === 0)
+        return null;
+    const pathSegs = segments(url.pathname);
+    for (const gw of gateways) {
+        try {
+            if (!gw || typeof gw.hostSuffix !== "string" || typeof gw.pathPattern !== "string")
+                continue;
+            if (!hostMatchesSuffix(host, gw.hostSuffix))
+                continue;
+            const patternSegs = segments(gw.pathPattern);
+            const providerIdx = patternSegs.findIndex((s) => s.toLowerCase() === ":provider");
+            if (providerIdx === -1 || pathSegs.length < patternSegs.length)
+                continue;
+            let ok = true;
+            for (let i = 0; i < patternSegs.length; i++) {
+                const p = patternSegs[i];
+                if (p.startsWith(":"))
+                    continue; // any single segment
+                if (p !== decodeURIComponentSafe(pathSegs[i])) {
+                    ok = false;
+                    break;
+                }
+            }
+            if (!ok)
+                continue;
+            const provider = providerFromToken(decodeURIComponentSafe(pathSegs[providerIdx]));
+            if (provider)
+                return { provider, gateway: host };
+        }
+        catch {
+            // malformed entry — skip
+        }
+    }
+    return null;
+}
+function decodeURIComponentSafe(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+/**
+ * Best-effort `gen_ai.operation.name` from the request path. Chat-style
+ * endpoints (OpenAI/Mistral `chat/completions`, Anthropic `messages`, Google
+ * `*generateContent`) → `chat`; `embeddings` → `embeddings`; bare/fim
+ * `completions` → `text_completion`; anything else defaults to `chat`.
+ */
+export function llmOperationName(pathname) {
+    const p = pathname.toLowerCase();
+    if (p.includes("/embeddings"))
+        return "embeddings";
+    if (p.includes("/chat/completions") || p.includes("/messages") || p.includes("generatecontent"))
+        return "chat";
+    if (p.endsWith("/completions") || p.includes("/completions"))
+        return "text_completion";
+    return "chat";
+}
 /** Best-effort gen_ai.request.* from a parsed JSON request body. Never throws. */
 export function llmRequestAttrs(provider, body) {
     const out = { "gen_ai.system": provider };
@@ -37,30 +137,29 @@ export function llmResponseAttrs(provider, body) {
     if (!body || typeof body !== "object" || Array.isArray(body))
         return out;
     const b = body;
+    // Response model / id. OpenAI, Mistral (OpenAI-compatible) and Anthropic use
+    // `model` / `id`; Google uses `modelVersion` / `responseId`.
     if (typeof b["model"] === "string")
         out["gen_ai.response.model"] = b["model"];
+    else if (typeof b["modelVersion"] === "string")
+        out["gen_ai.response.model"] = b["modelVersion"];
     if (typeof b["id"] === "string")
         out["gen_ai.response.id"] = b["id"];
-    // Usage tokens — OpenAI: usage.prompt_tokens / completion_tokens
-    //               Anthropic: usage.input_tokens / output_tokens
-    if (b["usage"] && typeof b["usage"] === "object" && !Array.isArray(b["usage"])) {
-        const usage = b["usage"];
-        // OpenAI shape
-        if (typeof usage["prompt_tokens"] === "number") {
-            out["gen_ai.usage.input_tokens"] = usage["prompt_tokens"];
-        }
-        if (typeof usage["completion_tokens"] === "number") {
-            out["gen_ai.usage.output_tokens"] = usage["completion_tokens"];
-        }
-        // Anthropic shape (overrides OpenAI if both somehow present)
-        if (typeof usage["input_tokens"] === "number") {
-            out["gen_ai.usage.input_tokens"] = usage["input_tokens"];
-        }
-        if (typeof usage["output_tokens"] === "number") {
-            out["gen_ai.usage.output_tokens"] = usage["output_tokens"];
-        }
+    else if (typeof b["responseId"] === "string")
+        out["gen_ai.response.id"] = b["responseId"];
+    // Usage tokens — OpenAI/Mistral: usage.prompt_tokens / completion_tokens
+    //               Anthropic:      usage.input_tokens / output_tokens
+    //               Google:         usageMetadata.promptTokenCount / candidatesTokenCount
+    Object.assign(out, usageAttrs(b["usage"]));
+    if (b["usageMetadata"] && typeof b["usageMetadata"] === "object" && !Array.isArray(b["usageMetadata"])) {
+        const um = b["usageMetadata"];
+        if (typeof um["promptTokenCount"] === "number")
+            out["gen_ai.usage.input_tokens"] = um["promptTokenCount"];
+        if (typeof um["candidatesTokenCount"] === "number")
+            out["gen_ai.usage.output_tokens"] = um["candidatesTokenCount"];
     }
-    // Finish reason — OpenAI: choices[0].finish_reason; Anthropic: stop_reason
+    // Finish reason — OpenAI/Mistral: choices[0].finish_reason; Anthropic:
+    // stop_reason; Google: candidates[0].finishReason
     if (typeof b["stop_reason"] === "string") {
         out["gen_ai.response.finish_reason"] = b["stop_reason"];
     }
@@ -70,9 +169,183 @@ export function llmResponseAttrs(provider, body) {
             out["gen_ai.response.finish_reason"] = choice["finish_reason"];
         }
     }
+    else if (Array.isArray(b["candidates"]) && b["candidates"].length > 0) {
+        const cand = b["candidates"][0];
+        if (cand && typeof cand === "object" && typeof cand["finishReason"] === "string") {
+            out["gen_ai.response.finish_reason"] = cand["finishReason"];
+        }
+    }
     void provider; // provider available for future provider-specific logic
     return out;
 }
+/** `gen_ai.usage.*` from an OpenAI-style or Anthropic-style `usage` object. */
+function usageAttrs(usage) {
+    const out = {};
+    if (!usage || typeof usage !== "object" || Array.isArray(usage))
+        return out;
+    const u = usage;
+    // OpenAI / Mistral shape
+    if (typeof u["prompt_tokens"] === "number")
+        out["gen_ai.usage.input_tokens"] = u["prompt_tokens"];
+    if (typeof u["completion_tokens"] === "number")
+        out["gen_ai.usage.output_tokens"] = u["completion_tokens"];
+    // Anthropic shape (overrides OpenAI if both somehow present)
+    if (typeof u["input_tokens"] === "number")
+        out["gen_ai.usage.input_tokens"] = u["input_tokens"];
+    if (typeof u["output_tokens"] === "number")
+        out["gen_ai.usage.output_tokens"] = u["output_tokens"];
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Streaming (SSE) usage scanning — metadata only, never content
+//
+// Every provider streams `text/event-stream`; token usage arrives in one or two
+// chunks: OpenAI (with `stream_options.include_usage`) and Mistral put a `usage`
+// object in the final data chunk; Anthropic sends `message_start` (model, id,
+// input_tokens) and `message_delta` (output_tokens, stop_reason); Google sends
+// `usageMetadata` on the final chunk. The scanner parses each `data:` line's
+// JSON just long enough to lift those fields and discards the chunk. Content
+// deltas are never retained or copied into attributes.
+// ---------------------------------------------------------------------------
+/** Lines longer than this are skipped unparsed (a bound on per-chunk JSON.parse). */
+export const SSE_MAX_LINE_BYTES = 64 * 1024;
+/**
+ * Metadata attrs from ONE parsed stream chunk. Shares the response mapper and
+ * adds the Anthropic envelope (`message.{id,model,usage}` on `message_start`,
+ * `delta.stop_reason` on `message_delta`). Never throws.
+ */
+export function llmStreamChunkAttrs(provider, chunk) {
+    const out = llmResponseAttrs(provider, chunk);
+    if (!chunk || typeof chunk !== "object" || Array.isArray(chunk))
+        return out;
+    const c = chunk;
+    const msg = c["message"];
+    if (msg && typeof msg === "object" && !Array.isArray(msg)) {
+        const m = msg;
+        if (typeof m["id"] === "string")
+            out["gen_ai.response.id"] = m["id"];
+        if (typeof m["model"] === "string")
+            out["gen_ai.response.model"] = m["model"];
+        Object.assign(out, usageAttrs(m["usage"]));
+    }
+    const delta = c["delta"];
+    if (delta && typeof delta === "object" && !Array.isArray(delta)) {
+        const d = delta;
+        if (typeof d["stop_reason"] === "string")
+            out["gen_ai.response.finish_reason"] = d["stop_reason"];
+    }
+    return out;
+}
+/**
+ * Incremental SSE scanner: buffers at most one partial line, parses complete
+ * `data:` lines for usage/model/id/finish_reason and drops everything else
+ * immediately. Lines over `SSE_MAX_LINE_BYTES` are skipped without parsing.
+ */
+export function createSseUsageScanner(provider) {
+    const acc = {};
+    let buf = "";
+    // When a line has already exceeded the cap, keep discarding until its newline.
+    let skipping = false;
+    const handleLine = (raw) => {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (!line.startsWith("data:"))
+            return; // event:/id:/retry:/comments
+        const payload = line.slice(5).trim();
+        if (!payload || payload === "[DONE]")
+            return;
+        if (payload.charCodeAt(0) !== 123 /* { */)
+            return;
+        try {
+            const chunk = JSON.parse(payload);
+            const attrs = llmStreamChunkAttrs(provider, chunk);
+            for (const k of Object.keys(attrs))
+                acc[k] = attrs[k];
+        }
+        catch {
+            // not JSON — ignore this line
+        }
+    };
+    return {
+        feed(text) {
+            try {
+                let start = 0;
+                for (;;) {
+                    const nl = text.indexOf("\n", start);
+                    if (nl === -1) {
+                        const rest = text.slice(start);
+                        if (skipping)
+                            break;
+                        if (buf.length + rest.length > SSE_MAX_LINE_BYTES) {
+                            buf = "";
+                            skipping = true;
+                            break;
+                        }
+                        buf += rest;
+                        break;
+                    }
+                    const piece = text.slice(start, nl);
+                    start = nl + 1;
+                    if (skipping) {
+                        skipping = false;
+                        buf = "";
+                        continue;
+                    }
+                    if (buf.length + piece.length > SSE_MAX_LINE_BYTES) {
+                        buf = "";
+                        continue; // oversize line — skip it whole
+                    }
+                    const line = buf + piece;
+                    buf = "";
+                    handleLine(line);
+                }
+            }
+            catch {
+                // never throw into the caller's stream
+            }
+        },
+        result() {
+            if (buf && !skipping) {
+                const line = buf;
+                buf = "";
+                handleLine(line);
+            }
+            return { ...acc };
+        },
+    };
+}
+/**
+ * Drain a (teed) SSE body through the scanner and resolve with the accumulated
+ * metadata attrs when the stream closes. Resolves — never rejects — on a stream
+ * error, returning whatever was scanned so far. Reads chunk-by-chunk with a
+ * streaming `TextDecoder`, so the body is never buffered.
+ */
+export async function scanSseStreamForUsage(stream, provider) {
+    const scanner = createSseUsageScanner(provider);
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                scanner.feed(decoder.decode(value, { stream: true }));
+        }
+        scanner.feed(decoder.decode());
+    }
+    catch {
+        // upstream error/cancel — keep what we have
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore
+        }
+    }
+    return scanner.result();
+}
 /** Content attrs, ONLY when captureContent is on. Size-capped per value, redactor applied. */
 export function llmContentAttrs(provider, reqBody, resBody, opts) {
     const out = {};

package/dist/node.js

@@ -3,7 +3,7 @@ import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
 import { ExportResultCode } from "@opentelemetry/core";
-import { Resource } from "@opentelemetry/resources";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import { buildExporterConfig, releaseResourceAttributes, } from "./core.js";
 import { isSelfSpanAttrs, safeHostname } from "./self-span.js";
 /**
@@ -132,7 +132,7 @@ export function initHeystack(o) {
         // Release/commit attribution. NodeSDK merges `serviceName` on top of this
         // resource, so the final resource carries service.name + (when provided)
         // service.version + service.build. Empty when neither option nor env is set.
-        resource: new Resource(resolveNodeReleaseAttributes(o)),
+        resource: resourceFromAttributes(resolveNodeReleaseAttributes(o)),
         traceExporter,
         instrumentations,
     });

package/dist/workers-bindings.d.ts

@@ -10,7 +10,7 @@ export interface InstrumentBindingsOpts {
      */
     startSpan: (name: string, attrs: Record<string, unknown>, kind?: SpanKind) => Span;
     /**
-     * `true`  → auto-detect and wrap all D1/KV/R2/Vectorize/AI/Queue/Service bindings.
+     * `true`  → auto-detect and wrap all supported Cloudflare bindings.
      * `string[]` → only wrap bindings whose env key is listed.
      */
     select: boolean | string[];
@@ -34,6 +34,9 @@ export declare function injectTraceparentArgs(args: any[], traceparent: string):
  * - Vectorize: `query`+`upsert`
  * - Workers AI: `run` (without `prepare`)
  * - Queue producer: `send`+`sendBatch`
+ * - Workflow: `get`+`create`+`createBatch`
+ * - Rate limit: `limit`
+ * - Analytics Engine: `writeDataPoint`
  * - Service binding / Fetcher: `fetch` (last branch; most generic)
  *
  * Unrecognised bindings are passed through unchanged.

package/dist/workers-bindings.js

@@ -1,9 +1,8 @@
 // ---------------------------------------------------------------------------
 // Cloudflare binding instrumentation for @heystack/otel/workers.
 //
-// Wraps D1, KV, R2, Vectorize, Workers AI, Queue producers, and Service
-// bindings with OTel child spans so that every binding operation is visible
-// as a child of the active request span.
+// Wraps stable Cloudflare binding APIs with OTel child spans so that binding
+// operations are visible as children of the active request span.
 //
 // WinterCG-safe: no `node:*` imports. Span factory is injected so the logic
 // is pure and unit-testable without a global provider.
@@ -45,6 +44,17 @@ function isQueueLike(b) {
     return (typeof b?.send === "function" &&
         typeof b?.sendBatch === "function");
 }
+function isWorkflowLike(b) {
+    return (typeof b?.get === "function" &&
+        typeof b?.create === "function" &&
+        typeof b?.createBatch === "function");
+}
+function isRateLimitLike(b) {
+    return typeof b?.limit === "function";
+}
+function isAnalyticsEngineLike(b) {
+    return typeof b?.writeDataPoint === "function";
+}
 /** Service binding / Fetcher: last branch — anything with `.fetch`. Prior branches
  *  exclude D1/R2/KV/Vectorize/AI/Queue, so order alone is sufficient. */
 function isServiceLike(b) {
@@ -69,12 +79,31 @@ async function runWithSpan(span, fn) {
         span.end();
     }
 }
+function runSyncWithSpan(span, fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        span.recordException(err instanceof Error ? err : new Error(String(err)));
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        throw err;
+    }
+    finally {
+        span.end();
+    }
+}
 // ---------------------------------------------------------------------------
 // Proxy helper — intercepts listed handlers, falls through to prototype for rest
 // ---------------------------------------------------------------------------
+const rawTarget = Symbol("heystack.rawBindingTarget");
 function makeProxy(target, handlers) {
     return new Proxy(target, {
         get(t, prop, receiver) {
+            if (prop === rawTarget)
+                return t;
             if (typeof prop === "string" && prop in handlers)
                 return handlers[prop];
             const val = Reflect.get(t, prop, receiver);
@@ -82,6 +111,9 @@ function makeProxy(target, handlers) {
         },
     });
 }
+function unwrapTarget(value) {
+    return (value?.[rawTarget] ?? value);
+}
 // ---------------------------------------------------------------------------
 // D1 wrappers
 // ---------------------------------------------------------------------------
@@ -112,6 +144,47 @@ function wrapD1(binding, opts) {
         prepare(sql) {
             return wrapD1Statement(binding.prepare(sql), sql, opts);
         },
+        batch(statements) {
+            if (isTracingSuppressed(context.active())) {
+                return binding.batch(statements.map(unwrapTarget));
+            }
+            const span = opts.startSpan("D1 batch", {
+                "db.system": "d1",
+                "db.operation.name": "batch",
+                "db.operation.batch.size": statements.length,
+            });
+            return runWithSpan(span, () => binding.batch(statements.map(unwrapTarget)));
+        },
+        exec(query) {
+            if (isTracingSuppressed(context.active()))
+                return binding.exec(query);
+            const span = opts.startSpan("D1 exec", {
+                "db.system": "d1",
+                "db.operation.name": "exec",
+            });
+            return runWithSpan(span, () => binding.exec(query));
+        },
+        withSession(...args) {
+            return wrapD1Session(binding.withSession(...args), opts);
+        },
+    });
+}
+function wrapD1Session(session, opts) {
+    return makeProxy(session, {
+        prepare(sql) {
+            return wrapD1Statement(session.prepare(sql), sql, opts);
+        },
+        batch(statements) {
+            if (isTracingSuppressed(context.active())) {
+                return session.batch(statements.map(unwrapTarget));
+            }
+            const span = opts.startSpan("D1 session batch", {
+                "db.system": "d1",
+                "db.operation.name": "batch",
+                "db.operation.batch.size": statements.length,
+            });
+            return runWithSpan(span, () => session.batch(statements.map(unwrapTarget)));
+        },
     });
 }
 // ---------------------------------------------------------------------------
@@ -131,6 +204,7 @@ function wrapKV(binding, opts, namespace) {
     };
     return makeProxy(binding, {
         get: wrapOp("get", (key) => key),
+        getWithMetadata: wrapOp("getWithMetadata", (key) => key),
         put: wrapOp("put", (key) => key),
         list: wrapOp("list"),
         delete: wrapOp("delete", (key) => key),
@@ -151,11 +225,56 @@ function wrapR2(binding, opts, bucket) {
         const span = opts.startSpan(`R2 ${op}`, attrs);
         return runWithSpan(span, () => binding[op](...args));
     };
+    const wrapMultipart = (upload, key) => makeProxy(upload, {
+        uploadPart: async (partNumber, ...args) => {
+            if (isTracingSuppressed(context.active())) {
+                return upload.uploadPart(partNumber, ...args);
+            }
+            const span = opts.startSpan("R2 uploadPart", {
+                "r2.bucket": bucket,
+                "r2.key": key,
+                "r2.multipart.part_number": partNumber,
+            });
+            return runWithSpan(span, () => upload.uploadPart(partNumber, ...args));
+        },
+        abort: wrapMultipartOp("abort", upload, key),
+        complete: wrapMultipartOp("complete", upload, key, (parts) => ({
+            "r2.multipart.part_count": parts.length,
+        })),
+    });
+    function wrapMultipartOp(op, upload, key, extraAttrs) {
+        return async (...args) => {
+            if (isTracingSuppressed(context.active()))
+                return upload[op](...args);
+            const span = opts.startSpan(`R2 ${op}`, {
+                "r2.bucket": bucket,
+                "r2.key": key,
+                ...extraAttrs?.(...args),
+            });
+            return runWithSpan(span, () => upload[op](...args));
+        };
+    }
     return makeProxy(binding, {
         get: wrapOp("get", (key) => key),
         put: wrapOp("put", (key) => key),
         head: wrapOp("head", (key) => key),
         delete: wrapOp("delete", (key) => key),
+        list: wrapOp("list"),
+        async createMultipartUpload(key, ...args) {
+            if (isTracingSuppressed(context.active())) {
+                const upload = await binding.createMultipartUpload(key, ...args);
+                return wrapMultipart(upload, key);
+            }
+            const span = opts.startSpan("R2 createMultipartUpload", {
+                "r2.bucket": bucket,
+                "r2.key": key,
+            });
+            const upload = await runWithSpan(span, () => binding.createMultipartUpload(key, ...args));
+            return wrapMultipart(upload, key);
+        },
+        resumeMultipartUpload(key, uploadId) {
+            return wrapMultipart(binding.resumeMultipartUpload(key, uploadId), key);
+        },
     });
 }
 // ---------------------------------------------------------------------------
@@ -261,6 +380,66 @@ function wrapQueue(binding, opts, name) {
             const span = opts.startSpan("Queue sendBatch", batchAttrs, SpanKind.PRODUCER);
             return runWithSpan(span, () => binding.sendBatch(...args));
         },
+        metrics: async (...args) => {
+            if (isTracingSuppressed(context.active()))
+                return binding.metrics(...args);
+            const span = opts.startSpan("Queue metrics", {
+                ...baseAttrs,
+                "messaging.operation": "metrics",
+            });
+            return runWithSpan(span, () => binding.metrics(...args));
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Workflow, rate-limit, and Analytics Engine bindings
+// ---------------------------------------------------------------------------
+function wrapWorkflow(binding, opts, name) {
+    const wrapOp = (op, kind, getCount) => async (...args) => {
+        if (isTracingSuppressed(context.active()))
+            return binding[op](...args);
+        const attrs = {
+            "cloudflare.binding.type": "workflow",
+            "cloudflare.binding.name": name,
+            "cloudflare.workflow.operation": op,
+        };
+        const count = getCount?.(...args);
+        if (count !== undefined)
+            attrs["cloudflare.workflow.batch.size"] = count;
+        const span = opts.startSpan(`Workflow ${op}`, attrs, kind);
+        return runWithSpan(span, () => binding[op](...args));
+    };
+    return makeProxy(binding, {
+        get: wrapOp("get", SpanKind.CLIENT),
+        create: wrapOp("create", SpanKind.PRODUCER),
+        createBatch: wrapOp("createBatch", SpanKind.PRODUCER, (batch) => batch.length),
+        deleteBatch: wrapOp("deleteBatch", SpanKind.CLIENT, (ids) => ids.length),
+    });
+}
+function wrapRateLimit(binding, opts, name) {
+    return makeProxy(binding, {
+        limit: async (...args) => {
+            if (isTracingSuppressed(context.active()))
+                return binding.limit(...args);
+            const span = opts.startSpan("RateLimit limit", {
+                "cloudflare.binding.type": "rate_limit",
+                "cloudflare.binding.name": name,
+            });
+            return runWithSpan(span, () => binding.limit(...args));
+        },
+    });
+}
+function wrapAnalyticsEngine(binding, opts, name) {
+    return makeProxy(binding, {
+        writeDataPoint(...args) {
+            if (isTracingSuppressed(context.active()))
+                return binding.writeDataPoint(...args);
+            const span = opts.startSpan("AnalyticsEngine writeDataPoint", {
+                "cloudflare.binding.type": "analytics_engine",
+                "cloudflare.binding.name": name,
+            });
+            return runSyncWithSpan(span, () => binding.writeDataPoint(...args));
+        },
     });
 }
 // ---------------------------------------------------------------------------
@@ -315,6 +494,9 @@ function wrapService(binding, opts, name) {
  * - Vectorize: `query`+`upsert`
  * - Workers AI: `run` (without `prepare`)
  * - Queue producer: `send`+`sendBatch`
+ * - Workflow: `get`+`create`+`createBatch`
+ * - Rate limit: `limit`
+ * - Analytics Engine: `writeDataPoint`
  * - Service binding / Fetcher: `fetch` (last branch; most generic)
  *
  * Unrecognised bindings are passed through unchanged.
@@ -356,6 +538,15 @@ export function instrumentEnv(env, opts) {
         else if (isQueueLike(binding)) {
             result[key] = wrapQueue(binding, opts, key);
         }
+        else if (isWorkflowLike(binding)) {
+            result[key] = wrapWorkflow(binding, opts, key);
+        }
+        else if (isRateLimitLike(binding)) {
+            result[key] = wrapRateLimit(binding, opts, key);
+        }
+        else if (isAnalyticsEngineLike(binding)) {
+            result[key] = wrapAnalyticsEngine(binding, opts, key);
+        }
         else if (isServiceLike(binding)) {
             result[key] = wrapService(binding, opts, key);
         }