@friggframework/core 2.0.0--canary.622.eb2c9bd.0 → 2.0.0--canary.622.ce0381c.0

package/README.md

@@ -232,7 +232,7 @@ class HubSpotIntegration extends IntegrationBase {
 
 // Read the durable usage store (never an APM):
 const frigg = createFriggCommands({ integrationClass: HubSpotIntegration });
-await frigg.usage.totals({ metric: 'records.synced', groupBy: 'integrationType' });
+await frigg.usage.getTotalsByDimension({ metric: 'records.synced', groupBy: 'integrationType' });
 ```
 
 **See:** [`telemetry/README.md`](telemetry/README.md) for the full guide

package/application/commands/usage-commands.js

@@ -1,31 +1,15 @@
-/**
- * Usage Commands
- *
- * Application Layer — the read/write surface over the durable usage store
- * (ADR-011 §5). Exposed as `frigg.usage.*` on the unified command object so
- * reports and integration code query usage without touching the repository.
- *
- * @example
- * const frigg = createFriggCommands({ integrationClass: MyIntegration });
- * await frigg.usage.totals({ metric: 'records.synced', groupBy: 'integrationType', since });
- * await frigg.usage.series({ metric: 'records.synced', integrationType: 'hubspot', bucket: 'day' });
- */
+// `frigg.usage.*` — the read/write surface over the durable usage store.
 const {
     createUsageRepository,
 } = require('../../usage/repositories/usage-repository-factory');
 const { computeUsageWindows } = require('../../telemetry/usage-windows');
 const { resolveNorthStarEntry } = require('../../telemetry/north-star');
 
-function createUsageCommands({ usageRepository, northStar = null } = {}) {
+function createUsageCommands({ usageRepository } = {}) {
     const repository = usageRepository || createUsageRepository();
 
     return {
-        /**
-         * Record a usage counter for a point in time. Callers pass `at` (a Date,
-         * default now) — NOT a raw window key — and both the day and hour windows
-         * are derived, matching how the auto-rollup persists so series() reads
-         * back consistently at either granularity.
-         */
+        // Increments both the day and hour window rows for `at`.
         async recordUsageCounter({
             integrationId,
             integrationType,
@@ -33,7 +17,8 @@ function createUsageCommands({ usageRepository, northStar = null } = {}) {
             value = 1,
             at = new Date(),
         }) {
-            for (const window of computeUsageWindows(at)) {
+            const windows = computeUsageWindows(at);
+            for (const window of windows) {
                 await repository.increment({
                     integrationId,
                     integrationType,
@@ -44,25 +29,20 @@ function createUsageCommands({ usageRepository, northStar = null } = {}) {
             }
         },
 
-        async totals(args) {
-            return repository.totals(args);
+        async getTotalsByDimension(args) {
+            return repository.getTotalsByDimension(args);
         },
 
-        async series(args) {
-            return repository.series(args);
+        async getTimeSeries(args) {
+            return repository.getTimeSeries(args);
         },
 
-        /**
-         * First-class North Star read (ADR-011 Decision 5). Resolves the
-         * configured counter for an integration type (byType wins over default),
-         * then returns its totals from the durable usage store. Returns `null`
-         * when no North Star is configured, so callers can branch without
-         * knowing the counter key. Trends read via `series({ metric })`.
-         */
-        async northStar({ integrationType, since, groupBy = 'integrationType', bucket } = {}) {
+        // Caller supplies the North Star config (Definition.telemetry.northStar);
+        // resolves the counter for the type (byType > default), null if none.
+        async getNorthStarTotals({ northStar, integrationType, since, groupBy = 'integrationType', bucket } = {}) {
             const entry = resolveNorthStarEntry(northStar, integrationType);
             if (!entry) return null;
-            const totals = await repository.totals({
+            const totals = await repository.getTotalsByDimension({
                 metric: entry.name,
                 groupBy,
                 since,

package/application/index.js

@@ -17,11 +17,6 @@ const { createUsageCommands } = require('./commands/usage-commands');
  *
  * @param {Object} params
  * @param {Object} params.integrationClass - Integration class (required)
- * @param {Object} [params.northStar] - Resolved North Star config
- *   (`Definition.telemetry.northStar`) so `frigg.usage.northStar(...)` can read
- *   it (ADR-011 Decision 5). Injected by the caller that owns the app definition
- *   (the handler/report runner) — the application layer never reaches up to load
- *   it. Omitted → usage reads report no North Star.
  * @returns {Object} Unified commands object with all CRUD operations
  *
  * @example
@@ -29,7 +24,7 @@ const { createUsageCommands } = require('./commands/usage-commands');
  * const user = await commands.createUser({ username: 'user@example.com' });
  * const credential = await commands.createCredential({ userId: user.id, ... });
  */
-function createFriggCommands({ integrationClass, northStar = null }) {
+function createFriggCommands({ integrationClass }) {
     // All commands use Frigg's default repositories and use cases
     const integrationCommands = createIntegrationCommands({ integrationClass });
 
@@ -57,9 +52,10 @@ function createFriggCommands({ integrationClass, northStar = null }) {
         // Process commands
         ...processCommands,
 
-        // Usage read/write (ADR-011) — nested to match `frigg.usage.*`.
-        // northStar injected by the caller (composition root), not loaded here.
-        usage: createUsageCommands({ northStar }),
+        // Usage read/write — nested to match `frigg.usage.*`. The North Star
+        // read takes its config as a call argument, so nothing telemetry-specific
+        // is threaded through this general factory.
+        usage: createUsageCommands(),
     };
 }
 

package/core/create-handler.js

@@ -153,8 +153,8 @@ const createHandler = (optionByName = {}) => {
                 ? usageRollup
                 : getUsageRollupSubscriber();
 
-        // Wire adopter-declared telemetry subscribers once per cold start
-        // (ADR-011 Decision 6). Memoized in the singleton, so this is a cheap
+        // Wire adopter-declared telemetry subscribers once per cold start.
+        // Memoized in the singleton, so this is a cheap
         // no-op after the first invocation.
         getPluginTelemetrySubscribers();
 

package/handlers/integration-event-dispatcher.js

@@ -25,7 +25,7 @@ class IntegrationEventDispatcher {
     }
 
     /**
-     * Resolve + invoke a handler, auto-instrumented (ADR-011 Decision 2). This
+     * Resolve + invoke a handler, auto-instrumented. This
      * is the seam for queue/webhook/defined-route dispatch; the `this.on` path
      * (user actions, lifecycle) is instrumented in IntegrationBase.send().
      */

package/index.js

@@ -143,7 +143,7 @@ module.exports = {
     createReportingRouter,
     createReportingRepository,
 
-    // telemetry (ADR-011)
+    // telemetry
     createTelemetry,
     getTelemetry,
     createUsageRepository,

package/integrations/integration-base.js

@@ -79,7 +79,7 @@ class IntegrationBase {
         // Tier 3 Integration Extensions — see packages/core/integrations/EXTENSIONS.md
         // Shape: { [bindingName]: { extension, handlers?: { [eventName]: methodName } } }
         extensions: {},
-        // Usage-counter opt-in (ADR-011). Declaring a canonical key opts into the
+        // Usage-counter opt-in. Declaring a canonical key opts into the
         // cross-integration comparison report + durable rollup; custom keys are
         // comparable within this integration type. Shape:
         //   usage: { canonical: ['records.synced', ...], custom: { 'deals.enriched': { unit, label } } }
@@ -108,7 +108,7 @@ class IntegrationBase {
         this.messages = { errors: [], warnings: [] };
         this._isHydrated = false;
 
-        // Telemetry (ADR-011): every instance carries the service so integration
+        // Telemetry: every instance carries the service so integration
         // code can call `this.telemetry.*`. Extracted before the record check so
         // passing only `telemetry` never triggers a hollow hydration. Bound to
         // this instance so emissions auto-carry `integration_type` for the usage
@@ -223,7 +223,7 @@ class IntegrationBase {
 
         this._isHydrated = Boolean(this.id);
 
-        // ADR-011 Decision 2: log the instance-open exactly once per hydrated
+        // Log the instance-open exactly once per hydrated
         // instance, carrying the standard identifier set — so an integration is
         // visible in telemetry even on a path that never dispatches a handler.
         // High-cardinality ids ride the bus context (3rd arg), never metric
@@ -249,7 +249,7 @@ class IntegrationBase {
     }
 
     /**
-     * Standard telemetry identifier set (ADR-011 Decision 3). Assembled from the
+     * Standard telemetry identifier set. Assembled from the
      * hydrated record (integrationId, userId, version), the static Definition
      * (integrationType, version fallback), and the environment (stage, appName).
      * High-cardinality ids (integrationId, userId) ride span baggage only — never
@@ -812,7 +812,7 @@ class IntegrationBase {
                 `Event ${event} is not defined in the Integration event object`
             );
         }
-        // Auto-instrument (ADR-011 Decision 2). This is the seam for user
+        // Auto-instrument. This is the seam for user
         // actions, config-options, and lifecycle events dispatched via `this.on`
         // (the queue/webhook/route paths go through IntegrationEventDispatcher).
         return instrumentHandler(

package/modules/requester/requester.js

@@ -44,7 +44,7 @@ class Requester extends Delegate {
         // Instance methods can use this.fetch without differentiating
         this.fetch = get(params, 'fetch', fetch);
 
-        // Telemetry (ADR-011). Defaults to the process singleton; overridable
+        // Telemetry. Defaults to the process singleton; overridable
         // for tests. Outbound requests are instrumented in `_request`.
         //
         // Attribution boundary: the `frigg.apimodule.requests` OTel metric fires
@@ -103,7 +103,7 @@ class Requester extends Delegate {
     };
 
     /**
-     * Instrumenting entry point (ADR-011 P7). Wraps the whole logical request —
+     * Instrumenting entry point. Wraps the whole logical request —
      * including retry/refresh recursion — in a single span + one
      * `frigg.apimodule.requests` counter, emitted on the `i === 0` boundary so
      * retries are never double-counted. The full URL rides the span only; the

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.622.eb2c9bd.0",
+    "version": "2.0.0--canary.622.ce0381c.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -45,9 +45,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.622.eb2c9bd.0",
-        "@friggframework/prettier-config": "2.0.0--canary.622.eb2c9bd.0",
-        "@friggframework/test": "2.0.0--canary.622.eb2c9bd.0",
+        "@friggframework/eslint-config": "2.0.0--canary.622.ce0381c.0",
+        "@friggframework/prettier-config": "2.0.0--canary.622.ce0381c.0",
+        "@friggframework/test": "2.0.0--canary.622.ce0381c.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -87,5 +87,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "eb2c9bde95b23f2f854fd5d78b2c5388ac5222d8"
+    "gitHead": "ce0381c83a8fdebf49352eb9cd6b38b360130025"
 }

package/reporting/reporting-router.js

@@ -40,7 +40,7 @@ function buildTypeLabels() {
 
 function createReportingRouter() {
     const reportingRepository = createReportingRepository();
-    // ADR-011 hand-off: enrich the report with feature-usage columns read from
+    // Enrich the report with feature-usage columns read from
     // the Frigg-owned usage store. Best-effort — a failure to construct it never
     // blocks the structural report.
     let usageRepository = null;

package/reporting/use-cases/list-integrations-report.js

@@ -26,7 +26,7 @@ class ListIntegrationsReport {
             throw new Error('reportingRepository is required');
         }
         this.reportingRepository = reportingRepository;
-        // Optional ADR-011 usage store (the ADR-010 hand-off). When present, the
+        // Optional usage store (the ADR-010 hand-off). When present, the
         // report's byType buckets are enriched with feature-usage columns read
         // ONLY from this store — never an external APM.
         this.usageRepository = usageRepository || null;
@@ -87,7 +87,7 @@ class ListIntegrationsReport {
             bucket.byStatus[statusKey] = (bucket.byStatus[statusKey] ?? 0) + 1;
         }
 
-        // Additive usage columns (ADR-011). Read per-type totals for each
+        // Additive usage columns. Read per-type totals for each
         // canonical counter; a type with no rows reads as 0. Guarded so a usage
         // store failure never breaks the structural report.
         if (this.usageRepository) {
@@ -118,7 +118,7 @@ class ListIntegrationsReport {
         try {
             const totalsByMetric = await Promise.all(
                 metrics.map(async (metric) => {
-                    const totals = await this.usageRepository.totals({
+                    const totals = await this.usageRepository.getTotalsByDimension({
                         metric,
                         groupBy: 'integrationType',
                     });

package/telemetry/README.md

@@ -55,6 +55,15 @@ const Definition = {
 defaults to `none` (no per-event cost, no data written to CloudWatch). Point
 `exporter` at an OTLP backend to turn export on.
 
+**Sampling (`sampleRatio`, `0..1`, default `1`):** the fraction of **traces**
+exported — a cost knob for high-traffic fleets (`0.1` ≈ keep 10%). Whole traces
+are sampled (trace-ID-based + parent-based, so a distributed trace is never
+half-kept), and it does **not** thin the durable **usage counters** — those stay
+exact at any ratio (they ride the event bus, not the sampled trace pipeline). It
+is **not** error-aware: a low ratio drops failed-run traces too, so for "keep all
+errors, sample the rest" use tail-based sampling at an OTel Collector, not this
+knob. Typical: `1.0` in dev, lower (e.g. `0.1`) in high-volume prod.
+
 ### Environment variables
 
 | Variable | Purpose |
@@ -154,7 +163,7 @@ const { createFriggCommands } = require('@friggframework/core');
 const frigg = createFriggCommands({ integrationClass: HubSpotIntegration });
 
 // Apples-to-apples comparison across integration types:
-await frigg.usage.totals({
+await frigg.usage.getTotalsByDimension({
     metric: 'records.synced',
     groupBy: 'integrationType', // or 'metric'
     since: daysAgo(30),
@@ -163,7 +172,7 @@ await frigg.usage.totals({
 // → [{ integrationType: 'hubspot', value: 4200 }, { integrationType: 'salesforce', value: 1180 }]
 
 // Trend series for one type (aggregated across its instances):
-await frigg.usage.series({
+await frigg.usage.getTimeSeries({
     metric: 'records.synced',
     integrationType: 'hubspot',
     from: daysAgo(7),
@@ -211,19 +220,24 @@ Read it as a first-class metric without knowing the configured key — the North
 Star resolves per integration type (`byType` wins over `default`):
 
 ```js
-// Resolves the configured counter for the type, then returns its totals.
-await frigg.usage.northStar({ integrationType: 'hubspot', since: daysAgo(30) });
+// The caller passes the North Star config it already holds (from the app
+// definition); this resolves the counter for the type and returns its totals.
+await frigg.usage.getNorthStarTotals({
+    northStar: definition.telemetry.northStar,
+    integrationType: 'hubspot',
+    since: daysAgo(30),
+});
 // → { metric: 'contacts_synced', totals: [{ integrationType: 'hubspot', value: 900 }] }
-// → null when no North Star is configured (caller branches without knowing keys)
+// → null when `northStar` is absent or has no entry for the type
 ```
 
 Or read it like any counter once you know the key:
-`frigg.usage.totals({ metric: 'contacts_synced' })`; trends via `frigg.usage.series({ metric })`.
+`frigg.usage.getTotalsByDimension({ metric: 'contacts_synced' })`; trends via `frigg.usage.getTimeSeries({ metric })`.
 
-> `northStar` config is injected at the composition root — the caller that owns
-> the app definition passes it in: `createFriggCommands({ integrationClass, northStar })`
-> (the application layer never reaches up to load it). Omitted → `northStar()`
-> returns `null`.
+> The North Star read takes its config as a **call argument** — nothing
+> telemetry-specific is threaded through `createFriggCommands`. The caller that
+> owns the app definition (e.g. a report runner) passes `telemetry.northStar` in;
+> omit it and `getNorthStarTotals()` returns `null`.
 
 ## Plugin / extension tap
 
@@ -286,7 +300,7 @@ this.telemetry.count / auto-instrumented seam
                               │     (discards on SQS redelivery — approximate contract)
                               └─ your plugin taps
 
-frigg.usage.totals / series ◄── UsageCounter store ──► reporting usage columns
+frigg.usage.getTotalsByDimension / getTimeSeries ◄── UsageCounter store ──► reporting usage columns
 ```
 
 - **Flush is Lambda-safe:** `create-handler` awaits a bounded `forceFlush` in a

package/telemetry/bind-telemetry-context.js

@@ -1,6 +1,6 @@
 /**
  * Wrap a telemetry service so an integration instance's emissions automatically
- * carry its `integration_type` (ADR-011). This lets developers write
+ * carry its `integration_type`. This lets developers write
  * `this.telemetry.count('records.synced', n, { entity })` with no per-call
  * boilerplate, while the usage rollup still attributes the counter to the right
  * integration type.

package/telemetry/canonical-counters.js

@@ -1,5 +1,5 @@
 /**
- * Canonical usage-counter vocabulary (ADR-011 Usage-Counter Contract §1).
+ * Canonical usage-counter vocabulary.
  *
  * These core-owned, versioned keys are the ONLY metrics guaranteed comparable
  * *across* integration types — they power ADR-010's apples-to-apples comparison

package/telemetry/exporters/console-exporter.js

@@ -0,0 +1,19 @@
+const {
+    TelemetryExporterInterface,
+} = require('./telemetry-exporter-interface');
+
+/** Console span/metric exporters — local-dev visibility, no network. */
+class ConsoleExporter extends TelemetryExporterInterface {
+    build() {
+        const {
+            ConsoleSpanExporter,
+        } = require('@opentelemetry/sdk-trace-base');
+        const { ConsoleMetricExporter } = require('@opentelemetry/sdk-metrics');
+        return {
+            traceExporter: new ConsoleSpanExporter(),
+            metricExporter: new ConsoleMetricExporter(),
+        };
+    }
+}
+
+module.exports = { ConsoleExporter };

package/telemetry/exporters/datadog-exporter.js

@@ -0,0 +1,11 @@
+const { OtlpExporter } = require('./otlp-exporter');
+
+/**
+ * Datadog ingests OTLP/HTTP directly, so today it behaves exactly like
+ * `OtlpExporter` (endpoint + headers). It is its own class so Datadog-specific
+ * presets (e.g. a default `DD-API-KEY` header) can be added later without
+ * touching the OTLP exporter or the registry.
+ */
+class DatadogExporter extends OtlpExporter {}
+
+module.exports = { DatadogExporter };

package/telemetry/exporters/honeycomb-exporter.js

@@ -0,0 +1,13 @@
+const { OtlpExporter } = require('./otlp-exporter');
+
+/** Honeycomb: an OTLP preset — default endpoint + `x-honeycomb-team` from apiKey. */
+class HoneycombExporter extends OtlpExporter {
+    constructor({ endpoint, apiKey, headers } = {}) {
+        super({
+            endpoint: endpoint || 'https://api.honeycomb.io',
+            headers: apiKey ? { 'x-honeycomb-team': apiKey } : headers,
+        });
+    }
+}
+
+module.exports = { HoneycombExporter };

package/telemetry/exporters/otlp-exporter.js

@@ -0,0 +1,42 @@
+const {
+    TelemetryExporterInterface,
+} = require('./telemetry-exporter-interface');
+
+/**
+ * OTLP/HTTP exporter to a configured endpoint (+ optional headers). With no
+ * endpoint the OTel SDK falls back to the standard `OTEL_EXPORTER_OTLP_ENDPOINT`
+ * env var, so `url` is left unset in that case.
+ */
+class OtlpExporter extends TelemetryExporterInterface {
+    constructor({ endpoint, headers } = {}) {
+        super();
+        this.endpoint = endpoint;
+        this.headers = headers;
+    }
+
+    build() {
+        const {
+            OTLPTraceExporter,
+        } = require('@opentelemetry/exporter-trace-otlp-http');
+        const {
+            OTLPMetricExporter,
+        } = require('@opentelemetry/exporter-metrics-otlp-http');
+        return {
+            traceExporter: new OTLPTraceExporter(this._options('/v1/traces')),
+            metricExporter: new OTLPMetricExporter(this._options('/v1/metrics')),
+        };
+    }
+
+    _options(path) {
+        return {
+            ...(this.endpoint ? { url: joinPath(this.endpoint, path) } : {}),
+            ...(this.headers ? { headers: this.headers } : {}),
+        };
+    }
+}
+
+function joinPath(base, path) {
+    return `${String(base).replace(/\/$/, '')}${path}`;
+}
+
+module.exports = { OtlpExporter };

package/telemetry/exporters/passthrough-exporter.js

@@ -0,0 +1,25 @@
+const {
+    TelemetryExporterInterface,
+} = require('./telemetry-exporter-interface');
+
+/**
+ * Adopter/test-supplied exporter instances, used as-is (e.g. in-memory exporters
+ * in tests, or an advanced adopter wiring its own OTel exporter). Pre-built
+ * instances win over a `type`.
+ */
+class PassthroughExporter extends TelemetryExporterInterface {
+    constructor({ traceExporter = null, metricExporter = null } = {}) {
+        super();
+        this.traceExporter = traceExporter;
+        this.metricExporter = metricExporter;
+    }
+
+    build() {
+        return {
+            traceExporter: this.traceExporter,
+            metricExporter: this.metricExporter,
+        };
+    }
+}
+
+module.exports = { PassthroughExporter };

package/telemetry/exporters/resolve-exporter.js

@@ -0,0 +1,39 @@
+const { PassthroughExporter } = require('./passthrough-exporter');
+const { ConsoleExporter } = require('./console-exporter');
+const { OtlpExporter } = require('./otlp-exporter');
+const { HoneycombExporter } = require('./honeycomb-exporter');
+const { DatadogExporter } = require('./datadog-exporter');
+
+// type → exporter adapter. Add a destination by adding a class + one entry.
+const EXPORTERS = {
+    console: ConsoleExporter,
+    otlp: OtlpExporter,
+    datadog: DatadogExporter,
+    honeycomb: HoneycombExporter,
+};
+
+/**
+ * Resolve the exporter adapter for a telemetry descriptor. Pre-built exporter
+ * instances (tests / advanced adopters) win over `type`; an unknown or absent
+ * type falls back to plain OTLP (which itself falls back to the standard OTLP
+ * env var). Replaces the former switch-based factory with polymorphic adapters.
+ *
+ * @returns {import('./telemetry-exporter-interface').TelemetryExporterInterface}
+ */
+function resolveExporter(descriptor = {}) {
+    if (descriptor.traceExporter || descriptor.metricExporter) {
+        return new PassthroughExporter(descriptor);
+    }
+    // Own-property check so a `type` matching an Object.prototype member
+    // ('constructor', 'toString', …) can't resolve an inherited key — unknown
+    // types must fall through to plain OTLP.
+    const Exporter = Object.prototype.hasOwnProperty.call(
+        EXPORTERS,
+        descriptor.type
+    )
+        ? EXPORTERS[descriptor.type]
+        : OtlpExporter;
+    return new Exporter(descriptor);
+}
+
+module.exports = { resolveExporter, EXPORTERS };

package/telemetry/exporters/telemetry-exporter-interface.js

@@ -0,0 +1,17 @@
+/**
+ * Port for a telemetry exporter: builds the OTel trace + metric exporter
+ * instances for one destination. Adapters (console, otlp, honeycomb, datadog, a
+ * passthrough for pre-built instances) implement `build()`. OpenTelemetry SDK
+ * packages are `require`d lazily inside `build()` so merely loading an adapter
+ * pulls in no OTel modules.
+ */
+class TelemetryExporterInterface {
+    /** @returns {{ traceExporter: object|null, metricExporter: object|null }} */
+    build() {
+        throw new Error(
+            'build() must be implemented by a TelemetryExporter subclass'
+        );
+    }
+}
+
+module.exports = { TelemetryExporterInterface };

package/telemetry/index.js

@@ -1,12 +1,15 @@
 const { createTelemetry, isNoOpExporter } = require('./telemetry-service');
-const { createNoOpTelemetry } = require('./no-op-telemetry');
+const {
+    TelemetryServiceInterface,
+} = require('./telemetry-service-interface');
+const { NoOpTelemetry } = require('./no-op-telemetry');
 const { createTelemetryEventBus } = require('./telemetry-event-bus');
 const { resolveTelemetryConfig } = require('./telemetry-config');
 const {
     getTelemetry,
     resetTelemetryForTests,
 } = require('./telemetry-singleton');
-const { buildExporters } = require('./exporters/exporter-factory');
+const { resolveExporter } = require('./exporters/resolve-exporter');
 const { instrumentHandler } = require('./instrument-handler');
 const { bindTelemetryContext } = require('./bind-telemetry-context');
 const { createUsageRollupSubscriber } = require('./usage-rollup-subscriber');
@@ -32,13 +35,14 @@ const {
 
 module.exports = {
     createTelemetry,
-    createNoOpTelemetry,
+    TelemetryServiceInterface,
+    NoOpTelemetry,
     createTelemetryEventBus,
     resolveTelemetryConfig,
     getTelemetry,
     resetTelemetryForTests,
     isNoOpExporter,
-    buildExporters,
+    resolveExporter,
     instrumentHandler,
     bindTelemetryContext,
     createUsageRollupSubscriber,

package/telemetry/instrument-handler.js

@@ -1,6 +1,6 @@
 /**
  * Wraps a single integration handler invocation with a span + the
- * `frigg.handler.invocations` counter (ADR-011 Decision 2). Shared by the two
+ * `frigg.handler.invocations` counter. Shared by the two
  * dispatch seams — `IntegrationBase.send()` and `IntegrationEventDispatcher` —
  * so both paths are instrumented identically.
  *