autotel 4.2.5 → 5.0.0

package/skills/autotel-frameworks/SKILL.md

@@ -1,17 +1,19 @@
 ---
 name: autotel-frameworks
 description: >
-  Hono, Fastify, TanStack Start, Cloudflare Workers. Middleware and init; getRequestLogger() in handlers. Load when adding Autotel to a web framework.
+  Hono, Fastify, TanStack Start, Cloudflare Workers, NestJS, SvelteKit, Elysia, Nuxt. Middleware and init; getRequestLogger() in handlers. Load when adding Autotel to a web framework.
 ---
 
-# Autotel — Framework Integration
+# Autotel: Framework Integration
 
 This skill builds on autotel-instrumentation. Read it first for init() and span creation.
 
-Use framework-specific middleware or wrappers to create a span per request; then call `getRequestLogger()` inside handlers. Each framework package (autotel-hono, autotel-tanstack, autotel-cloudflare) provides the glue.
+Use framework-specific middleware or wrappers to create a span per request; then call `getRequestLogger()` inside handlers. Most frameworks use `autotel-adapters` subpaths (or a thin wrapper package like `autotel-hono`, `autotel-tanstack`, `autotel-cloudflare`, `autotel-nuxt`).
 
 When adding new request/exception events in framework handlers, prefer correlated logs (`getRequestLogger().info/warn/error`) instead of introducing new `span.addEvent()` usage.
 
+For custom HTTP frameworks, start from `autotel-adapters/toolkit` (`defineFrameworkIntegration`, `createMiddlewareLogger`, `finishResponse` for streaming, `waitUntil` on edge runtimes).
+
 ## Setup
 
 ### Hono
@@ -46,13 +48,43 @@ See packages/autotel-tanstack and apps/example-tanstack-start: middleware and en
 
 ### Cloudflare Workers
 
-See packages/autotel-cloudflare: init at top level, wrap the fetch handler so each request gets a span. Use `getRequestLogger()` or trace context inside the handler.
+See packages/autotel-cloudflare: init at top level, wrap the fetch handler so each request gets a span. Use `getRequestLogger()` or trace context inside the handler. Pass `ctx.waitUntil` through adapter options so emit/drain completes after the response.
+
+### NestJS
+
+Use `AutotelInterceptor` from `autotel-adapters/nestjs` and `useLogger()` in controllers/services (see apps/example-nestjs):
+
+```typescript
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { AutotelInterceptor } from 'autotel-adapters/nestjs';
+
+@Module({
+  providers: [{ provide: APP_INTERCEPTOR, useClass: AutotelInterceptor }],
+})
+export class AppModule {}
+```
+
+### SvelteKit
+
+Add `autotelHandle()` in `hooks.server.ts` from `autotel-adapters/sveltekit`; call `useLogger()` in `+server.ts` / server loads. Use `finishResponse` semantics for streaming routes (see toolkit `stream-response`).
+
+### Elysia
+
+Wrap handlers with `withAutotelHandler()` from `autotel-adapters/elysia` (or the `autotel` alias); use `useLogger()` inside handlers (see apps/example-elysia).
+
+### Nuxt
+
+Add the `autotel-nuxt` module for zero-config Nitro wiring; server code can use `useLogger()` via `autotel-adapters/nitro` re-exports from `autotel-nuxt/runtime/nitro`.
 
 ## Core Patterns
 
 **Register middleware before routes:** Middleware creates the span; getRequestLogger() needs that active span.
 
-**Framework-specific packages:** autotel-hono, autotel-tanstack, autotel-cloudflare. Install the package for your framework and follow its README or CLAUDE.md.
+**Framework-specific packages:** autotel-hono, autotel-tanstack, autotel-cloudflare, autotel-nuxt. Adapter subpaths: autotel-adapters/{express,fastify,next,nitro,nestjs,sveltekit,elysia,...}. Install the package for your framework and follow its README or CLAUDE.md.
+
+**Streaming responses:** defer `emitNow` until the body finishes via adapter `finishResponse` / toolkit `bindStreamingResponseLifecycle`.
+
+**Edge drain:** pass `waitUntil` (Cloudflare `ExecutionContext`, etc.) so async emit/drain does not block the response.
 
 ## Common Mistakes
 
@@ -87,4 +119,7 @@ Source: packages/autotel-hono, docs/AGENT-GUIDE.md
 
 Targets autotel v2.23.x.
 
-See also: autotel-instrumentation/SKILL.md — init and spans. autotel-request-logging/SKILL.md — request logger usage.
+See also:
+
+- `autotel-instrumentation/SKILL.md` for init and spans
+- `autotel-request-logging/SKILL.md` for request logger usage

package/skills/autotel-instrumentation/SKILL.md

@@ -4,7 +4,7 @@ description: >
   trace(), span(), instrument(), init(). Factory vs direct pattern, name inference. Sync init; use node-require for optional deps. Load when wrapping handlers or functions with spans.
 ---
 
-# Autotel — Instrumentation
+# Autotel: Instrumentation
 
 Wrap functions and handlers with `trace()`, `span()`, or `instrument()`. Call `init()` once at app startup. Keep init synchronous; use `safeRequire`/`requireModule` for optional dependencies.
 
@@ -13,7 +13,7 @@ For new event emission, prefer correlated logs (OTel Logs API path) over adding
 ## Setup
 
 ```typescript
-import { init, trace } from 'autotel';
+import { init, trace, withTracing } from 'autotel';
 
 init({ service: 'my-app' });
 
@@ -25,12 +25,14 @@ const handler = trace(async (req: Request) => {
 With span context (attributes, request logger):
 
 ```typescript
-const handler = trace((ctx) => async (req: Request) => {
-  ctx.setAttribute('http.route', '/api/checkout');
-  const log = getRequestLogger(ctx);
-  log.set({ path: req.url });
-  return processRequest(req);
-});
+const handler = withTracing({ name: 'http.request' })(
+  (ctx) => async (req: Request) => {
+    ctx.setAttribute('http.route', '/api/checkout');
+    const log = getRequestLogger(ctx);
+    log.set({ path: req.url });
+    return processRequest(req);
+  },
+);
 ```
 
 ## Core Patterns
@@ -142,4 +144,7 @@ Source: packages/autotel/package.json exports
 
 Targets autotel v2.23.x.
 
-See also: autotel-core/SKILL.md — when to use what. autotel-request-logging/SKILL.md — getRequestLogger requires active span.
+See also:
+
+- `autotel-core/SKILL.md` for when to use what
+- `autotel-request-logging/SKILL.md`, since `getRequestLogger` requires an active span

package/skills/autotel-request-logging/SKILL.md

@@ -4,33 +4,35 @@ description: >
   getRequestLogger(), set(), info/warn/error, emitNow(). One snapshot per request; requires active span. Use when adding request-scoped context or replacing scattered console.log.
 ---
 
-# Autotel — Request Logging
+# Autotel: Request Logging
 
 This skill builds on autotel-instrumentation. Read it first for init and span creation.
 
-Accumulate context with `getRequestLogger(ctx)`, `.set()`, and `.info()`/`.warn()`/`.error()`. Call `.emitNow()` (or rely on middleware) to emit one snapshot per request. Request logger requires an active span — use inside `trace()` or framework middleware.
+Accumulate context with `getRequestLogger(ctx)`, `.set()`, and `.info()`/`.warn()`/`.error()`. Call `.emitNow()` (or rely on middleware) to emit one snapshot per request. Request logger requires an active span. Use inside `trace()` or framework middleware.
 
 Preferred event model: treat request logger emissions as the default way to capture request-correlated events in new code. If a backend still expects span-event rendering, keep compatibility at export/processor level rather than adding new `span.addEvent()` calls in application code.
 
 ## Setup
 
 ```typescript
-import { init, trace, getRequestLogger } from 'autotel';
+import { init, withTracing, getRequestLogger } from 'autotel';
 
 init({ service: 'my-app' });
 
-const handler = trace((ctx) => async (req: Request, res: Response) => {
-  const log = getRequestLogger(ctx);
-  log.set({ method: req.method, path: req.url });
+const handler = withTracing({ name: 'http.request' })(
+  (ctx) => async (req: Request, res: Response) => {
+    const log = getRequestLogger(ctx);
+    log.set({ method: req.method, path: req.url });
 
-  const user = await getAuth(req);
-  log.set({ user: { id: user.id } });
+    const user = await getAuth(req);
+    log.set({ user: { id: user.id } });
 
-  const result = await doWork(req);
-  log.set({ result: { id: result.id } });
-  log.emitNow();
-  return res.json(result);
-});
+    const result = await doWork(req);
+    log.set({ result: { id: result.id } });
+    log.emitNow();
+    return res.json(result);
+  },
+);
 ```
 
 When the framework creates the span (e.g. Hono middleware), call `getRequestLogger()` with no args:
@@ -91,4 +93,7 @@ Source: packages/autotel/src/request-logger.ts
 
 Targets autotel v2.23.x.
 
-See also: autotel-instrumentation/SKILL.md — creating the span. autotel-structured-errors/SKILL.md — use .error() to record errors in the snapshot.
+See also:
+
+- `autotel-instrumentation/SKILL.md` for creating the span
+- `autotel-structured-errors/SKILL.md`, which uses `.error()` to record errors in the snapshot

package/skills/autotel-structured-errors/SKILL.md

@@ -4,7 +4,7 @@ description: >
   createStructuredError, parseError, recordStructuredError. API errors with message, why, fix, link; client parsing for UI. Use in API routes and client catch blocks.
 ---
 
-# Autotel — Structured Errors
+# Autotel: Structured Errors
 
 Throw errors with `createStructuredError({ message, why?, fix?, link?, status?, cause? })` in API routes and services. On the client, use `parseError(caught)` to get `message`, `status`, `why`, `fix`, `link` for toasts and UI.
 
@@ -122,4 +122,4 @@ Source: docs/AGENT-GUIDE.md
 
 Targets autotel v2.23.x.
 
-See also: autotel-request-logging/SKILL.md — use .error() to record errors in the request snapshot.
+See also: autotel-request-logging/SKILL.md. Use .error() to record errors in the request snapshot.

package/skills/build-audit-trails/SKILL.md

@@ -17,9 +17,9 @@ license: MIT
 
 # Build audit trails
 
-An _audit trail_ is a record of who did what to which resource, when, and whether it was permitted — durable, tamper-evident, and admissible. Operational telemetry (latency, errors, span shapes) is for engineers; audit trails are for compliance, security, and forensics. They overlap technically but differ on every other axis.
+An _audit trail_ is a record of who did what to which resource, when, and whether it was permitted. Durable, tamper-evident, and admissible. Operational telemetry (latency, errors, span shapes) is for engineers; audit trails are for compliance, security, and forensics. They overlap technically but differ on every other axis.
 
-autotel lets you express both with the same primitive — a span — but you should keep them on **separate processors** so an audit event never gets dropped by sampling, never gets redacted by a debug rule, and never goes to the same backend as your ops data.
+autotel lets you express both with the same primitive, a span, but you should keep them on **separate processors** so an audit event never gets dropped by sampling, never gets redacted by a debug rule, and never goes to the same backend as your ops data.
 
 ## When to use
 
@@ -251,14 +251,14 @@ Verify on the read side: recompute the HMAC over the same sorted attribute set (
 
 For multi-tenant or extra-strict (HIPAA), use Ed25519 with per-environment keys and rotate.
 
-## Step 5: Redaction — what stays and what goes
+## Step 5: Redaction: what stays and what goes
 
 | Field                    | In audit span? | Notes                                                                                 |
 | ------------------------ | -------------- | ------------------------------------------------------------------------------------- |
 | `enduser.id`             | ✅             | Internal user id; never the email                                                     |
 | `audit.resource.id`      | ✅             | Required for forensics                                                                |
 | `client.address`         | ✅             | Last-octet redaction acceptable for IPv4                                              |
-| Free-form payload bodies | ❌             | Never inline raw input — link by id (`audit.evidence.id`)                             |
+| Free-form payload bodies | ❌             | Never inline raw input: link by id (`audit.evidence.id`)                              |
 | Secret values            | ❌             | Use `audit.action=secret.read` + `audit.resource.id=sec_abc`, never the secret itself |
 | Authorization headers    | ❌             | Token names ok (`bearer.*`), values never                                             |
 
@@ -356,7 +356,7 @@ app.post('/secrets/:id/read', async (c) => {
 
 ### Cloudflare Workers
 
-`audit()` from inside `defineWorkerFetch` — `ctx.waitUntil` makes sure the audit span is exported before the response returns:
+`audit()` from inside `defineWorkerFetch`. `ctx.waitUntil` makes sure the audit span is exported before the response returns:
 
 ```typescript
 export default defineWorkerFetch(
@@ -452,9 +452,9 @@ To query the trail (denials, per-actor history, tamper detection) across Honeyco
 
 ## Glossary
 
-- **Audit span** — an OpenTelemetry span that records who did what to which resource, marked `audit` / `autotel.audit` so it is routed and retained separately from ops telemetry.
-- **Force-keep** — opting a span out of tail sampling so it is always exported; `forceKeepAuditEvent()` sets the autotel tail-keep flags.
-- **Denial** — an authorization decision that blocked an action; recorded with `audit.outcome = 'deny'` and a reason. Logging denials is as important as logging successes.
-- **Hash-chain** — linking each audit record to the hash of the previous one so removing or reordering records is detectable.
-- **Crypto-shredding** — satisfying an erasure request by destroying the per-subject encryption key rather than deleting the immutable record.
-- **Append-only store** — a backend that rejects updates and deletes (S3 Object Lock, immutable bucket, WORM storage), the destination for audit spans.
+- **Audit span**: an OpenTelemetry span that records who did what to which resource, marked `audit` / `autotel.audit` so it is routed and retained separately from ops telemetry.
+- **Force-keep**: opting a span out of tail sampling so it is always exported; `forceKeepAuditEvent()` sets the autotel tail-keep flags.
+- **Denial**: an authorization decision that blocked an action; recorded with `audit.outcome = 'deny'` and a reason. Logging denials is as important as logging successes.
+- **Hash-chain**: linking each audit record to the hash of the previous one so removing or reordering records is detectable.
+- **Crypto-shredding**: satisfying an erasure request by destroying the per-subject encryption key rather than deleting the immutable record.
+- **Append-only store**: a backend that rejects updates and deletes (S3 Object Lock, immutable bucket, WORM storage), the destination for audit spans.

package/skills/build-audit-trails/references/audit-queries.md

@@ -8,7 +8,7 @@ Run these against the **audit backend** (the append-only one), not your ops back
 
 A spike in denials is a security signal (credential stuffing, privilege probing).
 
-- **Honeycomb** — filter `autotel.audit = true` AND `audit.outcome = deny`, group by `audit.action` and `enduser.id`, visualize `COUNT`.
+- **Honeycomb**: filter `autotel.audit = true` AND `audit.outcome = deny`, group by `audit.action` and `enduser.id`, visualize `COUNT`.
 - **Grafana Tempo (TraceQL)**:
   ```
   { span.autotel.audit = true && span.audit.outcome = "deny" }
@@ -22,7 +22,7 @@ A spike in denials is a security signal (credential stuffing, privilege probing)
 
 Answer "everything user X did" for an access review or incident.
 
-- **Honeycomb** — filter `enduser.id = "usr_42"`, group by `audit.action`, `audit.resource.type`, order by timestamp.
+- **Honeycomb**: filter `enduser.id = "usr_42"`, group by `audit.action`, `audit.resource.type`, order by timestamp.
 - **TraceQL**:
   ```
   { span.enduser.id = "usr_42" && span.autotel.audit = true }
@@ -49,7 +49,7 @@ Answer "everyone who accessed secret `sec_abc`".
 
 Confirm sensitive actions are actually being recorded. Group audit spans by `audit.action` and compare against your list of auditable actions. An action that never appears is either never exercised or never audited; both deserve a look.
 
-- **Honeycomb** — group by `audit.action`, `COUNT`, over 30 days.
+- **Honeycomb**: group by `audit.action`, `COUNT`, over 30 days.
 
 ## Detect tampering or missing signatures
 

package/skills/debug-missing-spans/SKILL.md

@@ -18,7 +18,7 @@ When a span you expect isn't in the backend, the cause is somewhere in this chai
 code → SDK init → head sampler → processor → exporter → network → backend ingest → backend index
 ```
 
-This skill walks each link in order with a quick check you can run. Don't skip steps — the cause is rarely where you'd guess.
+This skill walks each link in order with a quick check you can run. Don't skip steps. The cause is rarely where you'd guess.
 
 ## Step 0: Reproduce locally with the pretty exporter
 
@@ -31,7 +31,7 @@ init({
 });
 ```
 
-If you see the span in stdout, the SDK + sampler are fine — skip to "exporter / network". If you don't, keep reading.
+If you see the span in stdout, the SDK + sampler are fine. Skip to "exporter / network". If you don't, keep reading.
 
 ## Step 1: Is the SDK actually initialised?
 
@@ -60,9 +60,9 @@ console.log('[autotel-debug] sampling:', getActiveConfig()?.sampling);
 
 Common gotchas:
 
-- `sampling.rates: { server: 5 }` — 5 % means 95 % of spans never start.
+- `sampling.rates: { server: 5 }`: 5 % means 95 % of spans never start.
 - Inheriting `OTEL_TRACES_SAMPLER_ARG=0.01` from the environment via the OTel default sampler.
-- Your test happens to hit the unsampled branch — instrument with `sampling: { rates: { server: 100 } }` while reproducing.
+- Your test happens to hit the unsampled branch: instrument with `sampling: { rates: { server: 100 } }` while reproducing.
 
 To force sampling for one request, send a `traceparent` with the sampled flag set:
 
@@ -72,13 +72,13 @@ traceparent: 00-<traceid>-<spanid>-01
 
 (`-01` at the end = sampled.) autotel's parent-based sampler will respect it.
 
-## Step 3: Cloudflare Workers — `ctx.waitUntil`
+## Step 3: Cloudflare Workers: `ctx.waitUntil`
 
 The single biggest cause of missing spans on the edge: **the response returned before the exporter flushed**.
 
 If you're using `addEventListener('fetch', …)` or a hand-rolled `fetch` in a module worker without wiring `ctx.waitUntil(…)` to the export call, async drains drop silently.
 
-Fix — switch to `defineWorkerFetch` or `wrapModule`, both of which wire `waitUntil` automatically:
+Fix. Switch to `defineWorkerFetch` or `wrapModule`, both of which wire `waitUntil` automatically:
 
 ```typescript
 import { defineWorkerFetch } from 'autotel-cloudflare';
@@ -164,16 +164,16 @@ curl -v -X POST $OTLP_ENDPOINT \
   -d '{"resourceSpans":[]}'
 ```
 
-Should return `200`. If it doesn't, the problem is between you and the Collector — not autotel.
+Should return `200`. If it doesn't, the problem is between you and the Collector. Not autotel.
 
 For Cloudflare Workers, run `wrangler tail` and look for `OTLPExporter` errors.
 
-## Step 7: Backend ingest — silent rejection
+## Step 7: Backend ingest: silent rejection
 
 Some backends accept the request with a 200 but drop the events:
 
 - **Honeycomb**: dataset must exist _and_ the API key must have write access to it. Mismatched key/dataset → silent drop.
-- **Datadog**: check `service` is set (resource attribute `service.name`) — they ignore spans without it.
+- **Datadog**: check `service` is set (resource attribute `service.name`): they ignore spans without it.
 - **Sentry**: SDK version mismatch on envelope → 200 but events disappear.
 - **Grafana Cloud Tempo**: spans without `service.name` go to a fallback service called `unknown_service`.
 
@@ -219,9 +219,9 @@ Don't conclude the span is missing until you've waited > 2× the expected lag.
 
 Some spans land, some don't:
 
-- **Trace context broken between services** — outbound HTTP calls aren't propagating `traceparent`. Confirm autotel's global fetch instrumentation is on (`instrumentation.instrumentGlobalFetch: true`, default).
-- **Async boundary loses context** — a `setTimeout` / queue callback ran outside the AsyncLocalStorage scope. Wrap with `trace()` or use `context.with()`.
-- **Cross-runtime call** — Node service → Workers → browser; verify `traceparent` arrives at each leg via response headers / network panel.
+- **Trace context broken between services**: outbound HTTP calls aren't propagating `traceparent`. Confirm autotel's global fetch instrumentation is on (`instrumentation.instrumentGlobalFetch: true`, default).
+- **Async boundary loses context**: a `setTimeout` / queue callback ran outside the AsyncLocalStorage scope. Wrap with `trace()` or use `context.with()`.
+- **Cross-runtime call**: Node service → Workers → browser; verify `traceparent` arrives at each leg via response headers / network panel.
 
 ## When the SDK itself crashes
 

package/skills/migrate-to-autotel/SKILL.md

@@ -12,7 +12,7 @@ license: MIT
 
 # Migrate to autotel
 
-Replacing tracing in a live service is risky — you can lose data, change span shapes, or break dashboards your on-call team relies on. This skill covers the safe paths from each major source, what to change in your code, and how to verify the cutover before turning the old stack off.
+Replacing tracing in a live service is risky. You can lose data, change span shapes, or break dashboards your on-call team relies on. This skill covers the safe paths from each major source, what to change in your code, and how to verify the cutover before turning the old stack off.
 
 ## Choose your starting point
 
@@ -34,11 +34,11 @@ Replacing tracing in a live service is risky — you can lose data, change span
 4. **Disable the old stack.** Remove old SDK imports + processors; redeploy.
 5. **Decommission.** Remove old packages from `package.json` and lock files; archive old dashboards.
 
-Don't compress this into a single PR. The riskiest step is "disable old stack" — keep it last.
+Don't compress this into a single PR. The riskiest step is "disable old stack". Keep it last.
 
 ## From raw `@opentelemetry/sdk-node`
 
-The smoothest migration. autotel layers on top of OTel — your span attributes, propagators, and exporters can stay.
+The smoothest migration. autotel layers on top of OTel. Your span attributes, propagators, and exporters can stay.
 
 ### Drop-in init
 
@@ -76,15 +76,15 @@ init({
 
 ### What you gain immediately
 
-- `useLogger().set({ … })` flattens onto the active span — no more `span.setAttribute('user.id', id)` boilerplate.
-- `attributeRedactor: 'default'` — PII masking for free in production.
+- `useLogger().set({ … })` flattens onto the active span: no more `span.setAttribute('user.id', id)` boilerplate.
+- `attributeRedactor: 'default'`: PII masking for free in production.
 - `destinations: [...]` for straightforward OTLP multi-backend fan-out.
 - Cloudflare Workers + Edge support out of the box (`defineWorkerFetch`).
 
 ### What stays the same
 
 - Your propagator (`W3CTraceContextPropagator` is the default).
-- Your exporters — pass them via `spanProcessors` if you want to keep custom ones.
+- Your exporters: pass them via `spanProcessors` if you want to keep custom ones.
 - Your resource attributes.
 
 ## From Sentry performance tracing
@@ -148,7 +148,7 @@ Datadog APM uses its own format and proprietary tracer. The migration path is OT
 
 ### Step 1: Stop importing `dd-trace`
 
-`dd-trace` patches every supported library on import — keeping it in the bundle while autotel runs causes double-instrumentation. Remove `import 'dd-trace'` (or the `--require dd-trace/init` arg).
+`dd-trace` patches every supported library on import. Keeping it in the bundle while autotel runs causes double-instrumentation. Remove `import 'dd-trace'` (or the `--require dd-trace/init` arg).
 
 ### Step 2: Point autotel at Datadog OTLP intake
 
@@ -166,7 +166,7 @@ For the EU site use `datadoghq.eu`; for US3 / US5 see Datadog's region matrix.
 
 ### Step 3: Map Datadog span tags
 
-Datadog uses `service`, `resource`, `operation` — OTel uses `service.name`, `http.route`, span name. autotel handles the conversion automatically when exporting via `dd-api-key`. If you have custom Datadog tags in dashboards, rename them in code:
+Datadog uses `service`, `resource`, `operation`. OTel uses `service.name`, `http.route`, span name. autotel handles the conversion automatically when exporting via `dd-api-key`. If you have custom Datadog tags in dashboards, rename them in code:
 
 | Datadog tag | OTel attribute              |
 | ----------- | --------------------------- |
@@ -185,7 +185,7 @@ Datadog uses `service`, `resource`, `operation` — OTel uses `service.name`, `h
 
 ## From New Relic Node agent
 
-New Relic's agent is invasive — it patches Node internals. Plan a maintenance window for the cutover.
+New Relic's agent is invasive. It patches Node internals. Plan a maintenance window for the cutover.
 
 ### Step 1: Remove `--require newrelic`
 
@@ -214,7 +214,7 @@ For EU: `https://otlp.eu01.nr-data.net/v1/traces`.
 
 ## From Honeycomb Beelines
 
-Beelines for Node was Honeycomb's pre-OTel SDK. Migration is straightforward — Honeycomb supports OTLP natively.
+Beelines for Node was Honeycomb's pre-OTel SDK. Migration is straightforward. Honeycomb supports OTLP natively.
 
 ```typescript
 init({
@@ -234,7 +234,7 @@ init({
 
 Both are deprecated; the migration is "rewrite the tracer setup, leave call sites alone." OpenTracing's `Tracer.startSpan` and OpenCensus's `tracer.startRootSpan` shapes are similar enough that a script can replace them with `trace()` calls in most files.
 
-For libraries you don't control that still use OpenTracing, the OTel project ships a [shim](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-shim-opentracing) — wire it once, then migrate at your own pace.
+For libraries you don't control that still use OpenTracing, the OTel project ships a [shim](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-shim-opentracing). Wire it once, then migrate at your own pace.
 
 ## From unstructured logging
 
@@ -249,21 +249,21 @@ See [`review-otel-patterns`](../review-otel-patterns/SKILL.md) for the framework
 
 ## Verifying the cutover
 
-| Check                       | How                                                                                           |
-| --------------------------- | --------------------------------------------------------------------------------------------- |
-| **Span volume matches**     | Compare `count(spans)` per route over 24h; should be within ±5 %                              |
-| **p99 latency unchanged**   | Histograms on both backends                                                                   |
-| **Error rate unchanged**    | `count(spans where status=error)`                                                             |
-| **Trace correlation works** | Pick 10 random `traceId`s; confirm cross-service spans resolve                                |
-| **Bundle size acceptable**  | `pnpm bundle-size` — moving from heavy agents (New Relic, Datadog) often _shrinks_ the bundle |
+| Check                       | How                                                                                          |
+| --------------------------- | -------------------------------------------------------------------------------------------- |
+| **Span volume matches**     | Compare `count(spans)` per route over 24h; should be within ±5 %                             |
+| **p99 latency unchanged**   | Histograms on both backends                                                                  |
+| **Error rate unchanged**    | `count(spans where status=error)`                                                            |
+| **Trace correlation works** | Pick 10 random `traceId`s; confirm cross-service spans resolve                               |
+| **Bundle size acceptable**  | `pnpm bundle-size`: moving from heavy agents (New Relic, Datadog) often _shrinks_ the bundle |
 
 ## Anti-patterns
 
 | Anti-pattern                                              | Fix                                                                                                                           |
 | --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| Both old SDK and autotel running on the same library      | Pick one — double-instrumentation duplicates spans                                                                            |
+| Both old SDK and autotel running on the same library      | Pick one: double-instrumentation duplicates spans                                                                             |
 | Removing the old SDK in the same PR as adding autotel     | Run both side-by-side for 24–48 h first                                                                                       |
 | Changing span names during migration                      | Preserve names; rename in a separate PR after dashboards re-pointed                                                           |
 | No metric snapshot before cutover                         | Take p50/p95/p99 + error-rate baselines first                                                                                 |
-| Migrating prod before staging                             | Always staging first — at least 24 h                                                                                          |
+| Migrating prod before staging                             | Always staging first: at least 24 h                                                                                           |
 | Trusting the old vendor agent's auto-instrumentation list | autotel's targeted instrumentations (`autotel-drizzle`, `autotel-mongoose`, …) are faster and tighter; expect to add a couple |