@gobing-ai/ts-infra 0.2.8 → 0.2.9

package/dist/telemetry/otel-node.d.ts

@@ -0,0 +1,37 @@
+/** Options for {@link initNodeTelemetry}. */
+export interface NodeTelemetryOptions {
+    /** Logical service name emitted on every span/metric (resource attribute). */
+    serviceName: string;
+    /** Optional service version (resource attribute). */
+    serviceVersion?: string;
+    /**
+     * OTLP/HTTP collector endpoint base, e.g. `http://localhost:4318`.
+     * Signal-specific paths (`/v1/traces`, `/v1/metrics`) are appended by the
+     * exporters. When omitted, the OTel SDK default (`http://localhost:4318`)
+     * applies, honouring the standard `OTEL_EXPORTER_OTLP_*` env vars.
+     */
+    endpoint?: string;
+    /** Extra headers sent on every OTLP request (e.g. an auth token). */
+    headers?: Record<string, string>;
+    /** Metric export interval in ms. Default: 60_000. */
+    metricExportIntervalMs?: number;
+    /** When false, skip metric export and wire traces only. Default: true. */
+    metrics?: boolean;
+}
+/**
+ * Wire Node OTLP/HTTP export for traces and (by default) metrics, registering
+ * both providers globally. Idempotent: a second call is a no-op until
+ * {@link shutdownNodeTelemetry} runs.
+ *
+ * Call once at process startup, before the first span/metric is recorded.
+ */
+export declare function initNodeTelemetry(options: NodeTelemetryOptions): void;
+/**
+ * Flush and shut down the providers installed by {@link initNodeTelemetry}.
+ * Safe to call when nothing was initialised. Wire this to SIGTERM/SIGINT for a
+ * clean drain of buffered spans and metrics on shutdown.
+ */
+export declare function shutdownNodeTelemetry(): Promise<void>;
+/** Test-only: reset module state without requiring exporter teardown to resolve. */
+export declare function _resetNodeTelemetry(): void;
+//# sourceMappingURL=otel-node.d.ts.map

package/dist/telemetry/otel-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-node.d.ts","sourceRoot":"","sources":["../../src/telemetry/otel-node.ts"],"names":[],"mappings":"AAsBA,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACjC,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,qDAAqD;IACrD,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAKD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAoCrE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAY3D;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,IAAI,IAAI,CAI1C"}

package/dist/telemetry/otel-node.js

@@ -0,0 +1,85 @@
+/**
+ * Opt-in Node OTLP wiring for `@gobing-ai/ts-infra`.
+ *
+ * The core telemetry surface (`initTelemetry`, `getTracer`, the metric getters)
+ * only *instruments* — it records spans and metrics against whatever OTel
+ * provider is registered globally, and degrades to no-ops when none is. This
+ * subpath is the convenience layer that actually *exports*: it builds Node
+ * tracer + meter providers wired to OTLP/HTTP and registers them globally, so
+ * the already-instrumented call sites start flowing without any core change.
+ *
+ * Import this only when you want turnkey export. It pulls the OTLP exporter
+ * packages (declared as optional peers); the main barrel never imports them, so
+ * BYO-collector consumers stay lean and avoid global-provider conflicts.
+ */
+import { metrics } from '@opentelemetry/api';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import { BatchSpanProcessor, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+let traceProvider;
+let meterProvider;
+/**
+ * Wire Node OTLP/HTTP export for traces and (by default) metrics, registering
+ * both providers globally. Idempotent: a second call is a no-op until
+ * {@link shutdownNodeTelemetry} runs.
+ *
+ * Call once at process startup, before the first span/metric is recorded.
+ */
+export function initNodeTelemetry(options) {
+    if (traceProvider)
+        return;
+    const { serviceName, serviceVersion, endpoint, headers, metricExportIntervalMs = 60_000 } = options;
+    const wireMetrics = options.metrics ?? true;
+    const resource = resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: serviceName,
+        ...(serviceVersion ? { [ATTR_SERVICE_VERSION]: serviceVersion } : {}),
+    });
+    const traceExporter = new OTLPTraceExporter({
+        ...(endpoint ? { url: `${endpoint.replace(/\/$/, '')}/v1/traces` } : {}),
+        ...(headers ? { headers } : {}),
+    });
+    traceProvider = new NodeTracerProvider({
+        resource,
+        spanProcessors: [new BatchSpanProcessor(traceExporter)],
+    });
+    traceProvider.register();
+    if (wireMetrics) {
+        const metricExporter = new OTLPMetricExporter({
+            ...(endpoint ? { url: `${endpoint.replace(/\/$/, '')}/v1/metrics` } : {}),
+            ...(headers ? { headers } : {}),
+        });
+        const reader = new PeriodicExportingMetricReader({
+            exporter: metricExporter,
+            exportIntervalMillis: metricExportIntervalMs,
+        });
+        meterProvider = new MeterProvider({ resource, readers: [reader] });
+        metrics.setGlobalMeterProvider(meterProvider);
+    }
+}
+/**
+ * Flush and shut down the providers installed by {@link initNodeTelemetry}.
+ * Safe to call when nothing was initialised. Wire this to SIGTERM/SIGINT for a
+ * clean drain of buffered spans and metrics on shutdown.
+ */
+export async function shutdownNodeTelemetry() {
+    const pending = [];
+    if (meterProvider) {
+        pending.push(meterProvider.shutdown());
+        meterProvider = undefined;
+    }
+    if (traceProvider) {
+        pending.push(traceProvider.shutdown());
+        traceProvider = undefined;
+    }
+    metrics.disable();
+    await Promise.all(pending);
+}
+/** Test-only: reset module state without requiring exporter teardown to resolve. */
+export function _resetNodeTelemetry() {
+    meterProvider = undefined;
+    traceProvider = undefined;
+    metrics.disable();
+}

package/dist/telemetry/sdk.d.ts

@@ -1,11 +1,22 @@
 /**
- * OpenTelemetry SDK initialisation and tracer provider management.
+ * Telemetry enablement + tracer access.
+ *
+ * The core only *instruments* against whatever tracer provider is registered
+ * globally — it never constructs or owns a provider. Provider + exporter wiring
+ * is the consumer's concern: either the host app registers its own OTel SDK, or
+ * it opts into `@gobing-ai/ts-infra/otel-node` for turnkey OTLP export. This
+ * keeps the main barrel free of any SDK runtime dependency.
  */
 import { type Tracer } from '@opentelemetry/api';
 import type { TelemetryConfig } from './config';
 export declare function getResolvedConfig(): TelemetryConfig;
+/**
+ * Resolve telemetry config and mark telemetry enabled. Does not register any
+ * provider — spans flow to the globally-registered provider (none ⇒ no-op).
+ */
 export declare function initTelemetry(config?: Partial<TelemetryConfig>): void;
 export declare function shutdownTelemetry(): Promise<void>;
+/** The infra tracer from the globally-registered provider (no-op when none). */
 export declare function getTracer(): Tracer;
 export declare function isTelemetryEnabled(): boolean;
 export declare function _resetTelemetry(): void;

package/dist/telemetry/sdk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/telemetry/sdk.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,KAAK,MAAM,EAAS,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAShD,wBAAgB,iBAAiB,IAAI,eAAe,CAEnD;AAED,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAarE;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQvD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED,wBAAgB,eAAe,IAAI,IAAI,CAWtC;AAED,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/telemetry/sdk.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,MAAM,EAAS,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAShD,wBAAgB,iBAAiB,IAAI,eAAe,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAIrE;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAGjD;AAED,gFAAgF;AAChF,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAE5C;AAED,wBAAgB,eAAe,IAAI,IAAI,CAGtC;AAED,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/telemetry/sdk.js

@@ -1,53 +1,43 @@
 /**
- * OpenTelemetry SDK initialisation and tracer provider management.
+ * Telemetry enablement + tracer access.
+ *
+ * The core only *instruments* against whatever tracer provider is registered
+ * globally — it never constructs or owns a provider. Provider + exporter wiring
+ * is the consumer's concern: either the host app registers its own OTel SDK, or
+ * it opts into `@gobing-ai/ts-infra/otel-node` for turnkey OTLP export. This
+ * keeps the main barrel free of any SDK runtime dependency.
  */
 import { trace } from '@opentelemetry/api';
-import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import { getTelemetryConfig } from './config.js';
-let tracerProvider;
+const TRACER_NAME = '@gobing-ai/ts-infra';
+const TRACER_VERSION = '0.1.0';
 let telemetryInitialized = false;
 let resolvedConfig = getTelemetryConfig();
-const DEFAULT_TRACER = trace.getTracer('@gobing-ai/ts-infra', '0.1.0');
 export function getResolvedConfig() {
     return resolvedConfig;
 }
+/**
+ * Resolve telemetry config and mark telemetry enabled. Does not register any
+ * provider — spans flow to the globally-registered provider (none ⇒ no-op).
+ */
 export function initTelemetry(config) {
     if (telemetryInitialized)
         return;
     resolvedConfig = { ...getTelemetryConfig(), ...config };
-    if (!resolvedConfig.enabled) {
-        telemetryInitialized = true;
-        return;
-    }
-    tracerProvider = new NodeTracerProvider();
-    tracerProvider.register();
     telemetryInitialized = true;
 }
-export async function shutdownTelemetry() {
-    if (!tracerProvider) {
-        telemetryInitialized = false;
-        return;
-    }
-    await tracerProvider.shutdown();
-    tracerProvider = undefined;
+export function shutdownTelemetry() {
     telemetryInitialized = false;
+    return Promise.resolve();
 }
+/** The infra tracer from the globally-registered provider (no-op when none). */
 export function getTracer() {
-    return tracerProvider?.getTracer('@gobing-ai/ts-infra', '0.1.0') ?? DEFAULT_TRACER;
+    return trace.getTracer(TRACER_NAME, TRACER_VERSION);
 }
 export function isTelemetryEnabled() {
     return telemetryInitialized && resolvedConfig.enabled;
 }
 export function _resetTelemetry() {
-    if (tracerProvider) {
-        try {
-            tracerProvider.shutdown();
-        }
-        catch {
-            /* swallow */
-        }
-        tracerProvider = undefined;
-    }
     telemetryInitialized = false;
     resolvedConfig = getTelemetryConfig();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-infra",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "description": "@gobing-ai/ts-infra — Infrastructure backbone: event bus, job queue, scheduler, telemetry, API client, and logging.",
     "keywords": [
         "typescript",
@@ -31,6 +31,10 @@
         ".": {
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
+        },
+        "./otel-node": {
+            "types": "./dist/telemetry/otel-node.d.ts",
+            "import": "./dist/telemetry/otel-node.js"
         }
     },
     "files": [
@@ -50,18 +54,43 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-infra-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-db": "^0.2.8",
-        "@gobing-ai/ts-runtime": "^0.2.8"
+        "@gobing-ai/ts-db": "^0.2.9"
     },
     "peerDependencies": {
-        "@opentelemetry/api": "^1.9.0"
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/sdk-trace-node": "^2.0.0",
+        "@opentelemetry/sdk-metrics": "^2.0.0",
+        "@opentelemetry/resources": "^2.0.0",
+        "@opentelemetry/semantic-conventions": "^1.30.0",
+        "@opentelemetry/exporter-trace-otlp-http": ">=0.200.0",
+        "@opentelemetry/exporter-metrics-otlp-http": ">=0.200.0"
+    },
+    "peerDependenciesMeta": {
+        "@opentelemetry/sdk-trace-node": {
+            "optional": true
+        },
+        "@opentelemetry/sdk-metrics": {
+            "optional": true
+        },
+        "@opentelemetry/resources": {
+            "optional": true
+        },
+        "@opentelemetry/exporter-trace-otlp-http": {
+            "optional": true
+        },
+        "@opentelemetry/exporter-metrics-otlp-http": {
+            "optional": true
+        }
     },
     "devDependencies": {
         "@types/bun": "1.3.14",
         "@opentelemetry/api": "^1.9.0",
-        "@opentelemetry/sdk-trace-node": "^1.30.0",
-        "@opentelemetry/sdk-metrics": "^1.30.0",
-        "@opentelemetry/semantic-conventions": "^1.30.0"
+        "@opentelemetry/sdk-trace-node": "^2.0.0",
+        "@opentelemetry/sdk-metrics": "^2.0.0",
+        "@opentelemetry/resources": "^2.0.0",
+        "@opentelemetry/semantic-conventions": "^1.30.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.200.0",
+        "@opentelemetry/exporter-metrics-otlp-http": "^0.200.0"
     },
     "publishConfig": {
         "access": "public"

package/src/event-bus/event-bus.ts

@@ -1,5 +1,6 @@
 import type { JobQueue } from '../job-queue/types';
 import { getLogger, type Logger } from '../logger';
+import { getEventbusEmitsTotal, getEventbusErrorsTotal } from '../telemetry/metrics';
 import type {
     AsyncEnqueuedDetail,
     BusLifecycleEvents,
@@ -144,6 +145,9 @@ export class EventBus<TEvents extends EventMap> {
         const durationMs = performance.now() - startMs;
         const detail = args.length === 1 ? args[0] : args.length > 1 ? args : undefined;
 
+        getEventbusEmitsTotal().add(1, { event: eventName });
+        if (errors > 0) getEventbusErrorsTotal().add(errors, { event: eventName });
+
         this.publishEmitDone({ event: eventName, syncCount, asyncCount, emitDurationMs: durationMs, errors, detail });
 
         if (syncCount === 0 && asyncCount === 0) {

package/src/index.ts

@@ -4,9 +4,6 @@ export { APIClient, type APIClientConfig, APIError, type RequestOptions } from '
 // Event Bus
 export { EventBus, type EventMap, type SubscribeOptions } from './event-bus/index';
 
-// Events
-export type { AppEvents, AppInternalEvents } from './events/index';
-export { createSystemBus } from './events/index';
 export type {
     EnqueueOptions,
     Job,
@@ -40,17 +37,11 @@ export {
     addSpanEvent,
     extractSqlOperation,
     getActiveSpan,
-    getDbOperationDuration,
-    getDbOperationErrors,
-    getDbOperationTotal,
     getEventbusEmitsTotal,
     getEventbusErrorsTotal,
     getHttpClientRequestDuration,
     getHttpClientRequestErrors,
     getHttpClientRequestTotal,
-    getHttpServerRequestDuration,
-    getHttpServerRequestErrors,
-    getHttpServerRequestTotal,
     getQueueJobCompletedTotal,
     getQueueJobEnqueuedTotal,
     getQueueJobFailedTotal,

package/src/job-queue/db-job-queue.ts

@@ -1,4 +1,10 @@
 import type { QueueJobDao, QueueJobRecord, QueueStats } from '@gobing-ai/ts-db';
+import {
+    getQueueJobCompletedTotal,
+    getQueueJobEnqueuedTotal,
+    getQueueJobFailedTotal,
+    getQueueJobProcessingDuration,
+} from '../telemetry/metrics';
 import type { EnqueueOptions, Job, JobHandler, JobQueue, QueueConsumer, QueueConsumerConfig } from './types';
 
 /** DB-backed job queue implementation over `@gobing-ai/ts-db`'s `QueueJobDao`. */
@@ -6,11 +12,15 @@ export class DBJobQueue<T = unknown> implements JobQueue<T> {
     constructor(readonly dao: QueueJobDao) {}
 
     async enqueue(type: string, payload: T, options?: EnqueueOptions): Promise<string> {
-        return this.dao.enqueue(type, payload, options);
+        const id = await this.dao.enqueue(type, payload, options);
+        getQueueJobEnqueuedTotal().add(1, { type });
+        return id;
     }
 
     async enqueueBatch(jobs: Array<{ type: string; payload: T } & EnqueueOptions>): Promise<string[]> {
-        return this.dao.enqueueBatch(jobs);
+        const ids = await this.dao.enqueueBatch(jobs);
+        getQueueJobEnqueuedTotal().add(jobs.length);
+        return ids;
     }
 
     async stats(): Promise<QueueStats> {
@@ -121,10 +131,14 @@ export class DBQueueConsumer<T = unknown> implements QueueConsumer<T> {
             return;
         }
 
+        const startMs = performance.now();
         try {
             await handler(job);
             await this.dao.markCompleted(job.id);
+            getQueueJobCompletedTotal().add(1, { type: job.type });
+            getQueueJobProcessingDuration().record(performance.now() - startMs, { type: job.type });
         } catch (error) {
+            getQueueJobProcessingDuration().record(performance.now() - startMs, { type: job.type });
             await this.failOrRetry(job, error);
         }
     }
@@ -134,6 +148,7 @@ export class DBQueueConsumer<T = unknown> implements QueueConsumer<T> {
         const message = error instanceof Error ? error.message : String(error);
         if (attempts >= job.maxRetries) {
             await this.dao.markFailed(job.id, attempts, message);
+            getQueueJobFailedTotal().add(1, { type: job.type });
             return;
         }
 

package/src/job-queue/types.ts

@@ -28,6 +28,7 @@ export interface EnqueueOptions {
 export interface JobQueue<T = unknown> {
     enqueue(type: string, payload: T, options?: EnqueueOptions): Promise<string>;
     enqueueBatch(jobs: Array<{ type: string; payload: T } & EnqueueOptions>): Promise<string[]>;
+    stats(): Promise<QueueStats>;
 }
 
 export type JobHandler<T = unknown> = (job: Job<T>) => Promise<void>;
@@ -47,7 +48,6 @@ export interface QueueConsumerConfig {
     baseDelay?: number;
     maxDelay?: number;
     drainTimeoutMs?: number;
-    maxPollBackoff?: number;
 }
 
 export interface QueueConsumer<T = unknown> {

package/src/logger.ts

@@ -30,14 +30,14 @@ class ConsoleLogger implements Logger {
 
     constructor(
         private readonly category: string,
-        private readonly minLevel: LogLevel = 'info',
         context: Record<string, unknown> = {},
     ) {
         this.context = { category, ...context };
     }
 
     private log(level: LogLevel, msg: string, data?: Record<string, unknown>): void {
-        if (LEVEL_ORDER[level] < LEVEL_ORDER[this.minLevel]) return;
+        // Read the level dynamically so re-initialization affects cached loggers too.
+        if (LEVEL_ORDER[level] < LEVEL_ORDER[globalLevel]) return;
         if (globalMuted) return;
 
         const entry = {
@@ -86,7 +86,7 @@ class ConsoleLogger implements Logger {
     }
 
     child(context: Record<string, unknown>): Logger {
-        return new ConsoleLogger(this.category, this.minLevel, { ...this.context, ...context });
+        return new ConsoleLogger(this.category, { ...this.context, ...context });
     }
 }
 
@@ -109,7 +109,7 @@ export function getLogger(category: string): Logger {
     const existing = loggers.get(category);
     if (existing) return existing;
 
-    const logger = new ConsoleLogger(category, globalLevel);
+    const logger = new ConsoleLogger(category);
     loggers.set(category, logger);
     return logger;
 }

package/src/scheduler/cloudflare.ts

@@ -2,6 +2,7 @@
  * Cloudflare Workers scheduler adapter using Cron Triggers.
  * Uses minimal local type declarations — no @cloudflare/workers-types dependency.
  */
+import { getSchedulerJobExecutedTotal, getSchedulerJobFailedTotal } from '../telemetry/metrics';
 import type { ScheduledAction, SchedulerAdapter } from './types';
 
 interface CfScheduledEvent {
@@ -39,7 +40,13 @@ export class CloudflareSchedulerAdapter implements SchedulerAdapter {
     handleScheduledEvent(event: CfScheduledEvent, ctx: CfEventContext): void {
         const action = this.entries.get(event.cron);
         if (action) {
-            ctx.waitUntil(action());
+            getSchedulerJobExecutedTotal().add(1, { cron: event.cron });
+            ctx.waitUntil(
+                action().catch((error: unknown) => {
+                    getSchedulerJobFailedTotal().add(1, { cron: event.cron });
+                    throw error;
+                }),
+            );
         }
     }
 }

package/src/scheduler/factory.ts

@@ -1,6 +1,7 @@
 /**
  * Scheduler factory — selects adapter based on runtime.
  */
+import { NoopSchedulerAdapter } from './noop';
 import type { ScheduledAction, SchedulerAdapter } from './types';
 
 let runtimeAdapter: SchedulerAdapter | undefined;
@@ -30,7 +31,7 @@ export function getSchedulerAdapter(): SchedulerAdapter | undefined {
 export function initScheduler(cronEntries?: Array<[string, ScheduledAction]>): SchedulerAdapter {
     // Default: create a noop adapter. Apps inject their own via setSchedulerAdapter.
     if (!runtimeAdapter) {
-        runtimeAdapter = createNoopScheduler();
+        runtimeAdapter = new NoopSchedulerAdapter();
     }
 
     if (cronEntries) {
@@ -41,17 +42,3 @@ export function initScheduler(cronEntries?: Array<[string, ScheduledAction]>): S
 
     return runtimeAdapter;
 }
-
-function createNoopScheduler(): SchedulerAdapter {
-    return {
-        register(): void {
-            /* noop */
-        },
-        start(): Promise<void> {
-            return Promise.resolve();
-        },
-        stop(): Promise<void> {
-            return Promise.resolve();
-        },
-    };
-}

package/src/scheduler/node.ts

@@ -2,6 +2,11 @@
  * Node.js scheduler adapter using a simple setInterval-based approach.
  * No external cron library dependency — cron expressions are parsed minimally.
  */
+import {
+    getSchedulerJobDuration,
+    getSchedulerJobExecutedTotal,
+    getSchedulerJobFailedTotal,
+} from '../telemetry/metrics';
 import type { ScheduledAction, SchedulerAdapter } from './types';
 
 /** Simple helper to parse cron-like interval strings into milliseconds. */
@@ -74,10 +79,15 @@ export class NodeSchedulerAdapter implements SchedulerAdapter {
     }
 
     private async _onScheduledTick(entry: ScheduledEntry): Promise<void> {
+        const startMs = performance.now();
+        getSchedulerJobExecutedTotal().add(1, { cron: entry.cron });
         try {
             await entry.action();
         } catch {
             // Swallow — scheduler errors should not crash the process
+            getSchedulerJobFailedTotal().add(1, { cron: entry.cron });
+        } finally {
+            getSchedulerJobDuration().record(performance.now() - startMs, { cron: entry.cron });
         }
     }
 }

package/src/telemetry/config.ts

@@ -9,10 +9,6 @@ export interface TelemetryConfig {
     serviceName: string;
     /** Deployment environment (development, staging, production). */
     environment: string;
-    /** OTLP exporter endpoint (e.g. `http://localhost:4318/v1/traces`). */
-    exporterEndpoint?: string | undefined;
-    /** Export protocol — only `http` is supported in v1. */
-    exporterProtocol: 'http';
     /**
      * Debug-only DB statement capture.
      *
@@ -32,7 +28,6 @@ export interface TelemetryConfigPartial {
     enabled?: boolean | undefined;
     serviceName?: string | undefined;
     environment?: string | undefined;
-    exporterEndpoint?: string | undefined;
     dbStatementDebug?: boolean | undefined;
     /** Deployment environment fallback (from app.env). */
     appEnv?: string | undefined;
@@ -42,7 +37,6 @@ const DEFAULTS = {
     enabled: true as const,
     serviceName: 'ts-libs' as const,
     environment: 'development' as const,
-    exporterProtocol: 'http' as const,
 };
 
 /**
@@ -56,8 +50,6 @@ export function getTelemetryConfig(configPartial: TelemetryConfigPartial = {}):
         enabled,
         serviceName,
         environment: configPartial.environment ?? configPartial.appEnv ?? DEFAULTS.environment,
-        exporterEndpoint: configPartial.exporterEndpoint,
-        exporterProtocol: DEFAULTS.exporterProtocol,
         dbStatementDebug: configPartial.dbStatementDebug ?? false,
     };
 }

package/src/telemetry/index.ts

@@ -2,17 +2,11 @@ export { getTelemetryConfig, type TelemetryConfig, type TelemetryConfigPartial }
 export { extractSqlOperation, sanitizeSql } from './db-sanitize';
 export {
     type Counter,
-    getDbOperationDuration,
-    getDbOperationErrors,
-    getDbOperationTotal,
     getEventbusEmitsTotal,
     getEventbusErrorsTotal,
     getHttpClientRequestDuration,
     getHttpClientRequestErrors,
     getHttpClientRequestTotal,
-    getHttpServerRequestDuration,
-    getHttpServerRequestErrors,
-    getHttpServerRequestTotal,
     getQueueJobCompletedTotal,
     getQueueJobEnqueuedTotal,
     getQueueJobFailedTotal,