@watchtowerobservability/node 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -7,9 +7,13 @@
7
7
  GitHub Packages needs a token with `read:packages` even for public packages:
8
8
 
9
9
  ```sh
10
- npm install @watchtowerobservability/node
10
+ npm install @watchtowerobservability/node @opentelemetry/context-async-hooks @opentelemetry/core \
11
+ @opentelemetry/exporter-logs-otlp-http @opentelemetry/exporter-metrics-otlp-http @opentelemetry/exporter-trace-otlp-http \
12
+ @opentelemetry/otlp-transformer @opentelemetry/resources @opentelemetry/sdk-logs @opentelemetry/sdk-metrics @opentelemetry/sdk-trace
11
13
  ```
12
14
 
15
+ `@opentelemetry/api` is the only hard dependency; the OpenTelemetry SDK packages above are optional peers (so your app controls their versions) and are loaded by `init`, which throws an error naming the missing ones.
16
+
13
17
  Or install the attested tarball from a release without a token:
14
18
  `npm install https://github.com/watchtowerobservability/watchtower-node/releases/download/v0.2.0/watchtowerobservability-node-0.2.0.tgz`.
15
19
 
@@ -1,7 +1,6 @@
1
- import type { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
1
+ import type { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace';
2
2
  import type { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
3
- import { AggregationTemporality } from '@opentelemetry/sdk-metrics';
4
- import type { InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
3
+ import type { AggregationTemporality, InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
5
4
  type Done = Parameters<SpanExporter['export']>[1];
6
5
  /** What the spool wraps: a span, log record or metric exporter; `B` is one export batch. */
7
6
  export interface BatchExporter<B> {
@@ -40,14 +40,14 @@ exports.MetricSpool = exports.spoolLogs = exports.SpoolExporter = exports.encode
40
40
  const fs = __importStar(require("node:fs"));
41
41
  const path = __importStar(require("node:path"));
42
42
  const crypto = __importStar(require("node:crypto"));
43
- const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
44
- const otlp_transformer_1 = require("@opentelemetry/otlp-transformer");
43
+ const load_js_1 = require("./load.js");
44
+ const ser = () => (0, load_js_1.need)('@opentelemetry/otlp-transformer');
45
45
  /** OTLP/JSON encoders for the three signals. */
46
- const encodeSpans = (spans) => Buffer.from(otlp_transformer_1.JsonTraceSerializer.serializeRequest(spans));
46
+ const encodeSpans = (spans) => Buffer.from(ser().JsonTraceSerializer.serializeRequest(spans));
47
47
  exports.encodeSpans = encodeSpans;
48
- const encodeLogs = (logs) => Buffer.from(otlp_transformer_1.JsonLogsSerializer.serializeRequest(logs));
48
+ const encodeLogs = (logs) => Buffer.from(ser().JsonLogsSerializer.serializeRequest(logs));
49
49
  exports.encodeLogs = encodeLogs;
50
- const encodeMetrics = (rm) => Buffer.from(otlp_transformer_1.JsonMetricsSerializer.serializeRequest(rm));
50
+ const encodeMetrics = (rm) => Buffer.from(ser().JsonMetricsSerializer.serializeRequest(rm));
51
51
  exports.encodeMetrics = encodeMetrics;
52
52
  class SpoolExporter {
53
53
  inner;
@@ -125,7 +125,7 @@ class MetricSpool extends SpoolExporter {
125
125
  }
126
126
  selectAggregationTemporality(t) {
127
127
  const pick = this.metricInner.selectAggregationTemporality;
128
- return pick ? pick.call(this.metricInner, t) : sdk_metrics_1.AggregationTemporality.CUMULATIVE; // the SDK default
128
+ return pick ? pick.call(this.metricInner, t) : 1; // CUMULATIVE, the SDK default (enum value, so sdk-metrics is not imported eagerly)
129
129
  }
130
130
  forceFlush() {
131
131
  return this.metricInner.forceFlush();
@@ -1,8 +1,9 @@
1
1
  import { inspect } from 'node:util';
2
2
  import { metrics, trace } from '@opentelemetry/api';
3
3
  import type { Tracer } from '@opentelemetry/api';
4
- import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
5
- import { LoggerProvider } from '@opentelemetry/sdk-logs';
4
+ import type { Resource } from '@opentelemetry/resources';
5
+ import type { TracerProvider } from '@opentelemetry/sdk-trace';
6
+ import type { LoggerProvider } from '@opentelemetry/sdk-logs';
6
7
  import type { MeterProvider } from '@opentelemetry/sdk-metrics';
7
8
  import { captureException } from './errors.js';
8
9
  import type { CaptureContext } from './errors.js';
@@ -79,7 +80,8 @@ export declare class Client {
79
80
  };
80
81
  readonly fetch: typeof fetch;
81
82
  readonly redact: InitOptions['redact'];
82
- readonly provider: NodeTracerProvider;
83
+ readonly provider: TracerProvider;
84
+ readonly resource: Resource;
83
85
  readonly tracer: Tracer;
84
86
  readonly loggerProvider: LoggerProvider;
85
87
  readonly logger: ReturnType<LoggerProvider['getLogger']>;
package/dist/cjs/index.js CHANGED
@@ -42,12 +42,7 @@ const node_util_1 = require("node:util");
42
42
  const api_1 = require("@opentelemetry/api");
43
43
  Object.defineProperty(exports, "metrics", { enumerable: true, get: function () { return api_1.metrics; } });
44
44
  Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return api_1.trace; } });
45
- const resources_1 = require("@opentelemetry/resources");
46
- const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
47
- const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
48
- const sdk_logs_1 = require("@opentelemetry/sdk-logs");
49
- const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
50
- const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
45
+ const load_js_1 = require("./load.js");
51
46
  const buffer_js_1 = require("./buffer.js");
52
47
  const metrics_js_1 = require("./metrics.js");
53
48
  const nodePath = __importStar(require("node:path"));
@@ -73,6 +68,7 @@ class Client {
73
68
  fetch;
74
69
  redact;
75
70
  provider;
71
+ resource;
76
72
  tracer;
77
73
  loggerProvider;
78
74
  logger;
@@ -95,38 +91,48 @@ class Client {
95
91
  this.fetch = o.fetch || globalThis.fetch;
96
92
  const environment = o.environment || env.WT_ENVIRONMENT;
97
93
  const release = o.release || env.WT_RELEASE;
98
- const resource = new resources_1.Resource({
94
+ // the OTel SDK packages are optional peers, loaded here (not at import time) with a clear error when missing
95
+ const { resourceFromAttributes } = (0, load_js_1.need)('@opentelemetry/resources');
96
+ const resource = resourceFromAttributes({
99
97
  'service.name': o.serviceName || env.WT_SERVICE || 'app',
100
98
  ...(environment ? { 'deployment.environment.name': environment } : {}),
101
99
  ...(release ? { 'service.version': release } : {}),
102
100
  ...safeResource(o.resource),
103
101
  });
102
+ this.resource = resource;
104
103
  this.redact = o.redact;
105
- this.provider = new sdk_trace_node_1.NodeTracerProvider({ resource });
106
- if (o.redact)
107
- this.provider.addSpanProcessor(redactor(o.redact));
108
104
  let exporter = o.exporter;
109
105
  if (!exporter) {
110
106
  const url = `${this.endpoint}/v1/traces`;
111
- exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({ url, headers: this.headers });
107
+ const { OTLPTraceExporter } = (0, load_js_1.need)('@opentelemetry/exporter-trace-otlp-http');
108
+ exporter = new OTLPTraceExporter({ url, headers: this.headers });
112
109
  // spans and log records spool to their own subdirectories
113
110
  if (o.bufferDir)
114
111
  exporter = new buffer_js_1.SpoolExporter(exporter, nodePath.join(o.bufferDir, 'traces'), url, this.headers, this.fetch);
115
112
  }
116
- this.provider.addSpanProcessor(new sdk_trace_base_1.BatchSpanProcessor(exporter));
113
+ // the redactor runs first, so the batch processor exports redacted attributes
114
+ const { BatchSpanProcessor, TracerProvider: TP } = (0, load_js_1.need)('@opentelemetry/sdk-trace');
115
+ this.provider = new TP({
116
+ resource,
117
+ spanProcessors: [...(o.redact ? [redactor(o.redact)] : []), new BatchSpanProcessor({ exporter })],
118
+ });
117
119
  this.tracer = this.provider.getTracer('watchtower');
118
- this.loggerProvider = new sdk_logs_1.LoggerProvider({ resource });
119
120
  const logsOn = (0, metrics_js_1.switchOn)('WATCHTOWER_LOGS', 'OTEL_LOGS_EXPORTER', o.logs);
120
121
  let logExporter = logsOn ? o.logExporter : undefined;
121
122
  if (logsOn && !logExporter && !o.exporter) {
122
123
  const url = `${this.endpoint}/v1/logs`;
123
- logExporter = new exporter_logs_otlp_http_1.OTLPLogExporter({ url, headers: this.headers });
124
+ const { OTLPLogExporter } = (0, load_js_1.need)('@opentelemetry/exporter-logs-otlp-http');
125
+ logExporter = new OTLPLogExporter({ url, headers: this.headers });
124
126
  if (o.bufferDir)
125
127
  logExporter = (0, buffer_js_1.spoolLogs)(logExporter, nodePath.join(o.bufferDir, 'logs'), url, this.headers, this.fetch);
126
128
  }
127
- if (logExporter) {
128
- this.loggerProvider.addLogRecordProcessor(o.logExporter ? new sdk_logs_1.SimpleLogRecordProcessor(logExporter) : new sdk_logs_1.BatchLogRecordProcessor(logExporter));
129
- }
129
+ const { LoggerProvider: LP, SimpleLogRecordProcessor, BatchLogRecordProcessor } = (0, load_js_1.need)('@opentelemetry/sdk-logs');
130
+ this.loggerProvider = new LP({
131
+ resource,
132
+ processors: !logExporter ? [] : [o.logExporter
133
+ ? new SimpleLogRecordProcessor({ exporter: logExporter })
134
+ : new BatchLogRecordProcessor({ exporter: logExporter })],
135
+ });
130
136
  this.logger = this.loggerProvider.getLogger('watchtower');
131
137
  // with a test span exporter only an explicit metric exporter is used, as for logs
132
138
  if ((0, metrics_js_1.switchOn)('WATCHTOWER_METRICS', 'OTEL_METRICS_EXPORTER', o.metrics) && (o.metricExporter || !o.exporter)) {
@@ -273,13 +279,23 @@ function init(opts) {
273
279
  void current?.profiler?.then((p) => p?.stop());
274
280
  const c = new Client(opts);
275
281
  current = c;
276
- c.provider.register(); // global tracer + async context so trace.getActiveSpan() works
282
+ // Global tracer + async context so trace.getActiveSpan() works; a re-init replaces the previous client's.
283
+ api_1.trace.disable();
284
+ api_1.context.disable();
285
+ api_1.propagation.disable();
286
+ const { AsyncLocalStorageContextManager } = (0, load_js_1.need)('@opentelemetry/context-async-hooks');
287
+ const { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } = (0, load_js_1.need)('@opentelemetry/core');
288
+ api_1.context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
289
+ api_1.propagation.setGlobalPropagator(new CompositePropagator({
290
+ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()],
291
+ }));
292
+ api_1.trace.setGlobalTracerProvider(c.provider);
277
293
  if (c.meterProvider) {
278
294
  api_1.metrics.disable(); // a re-init replaces the previous client's provider
279
295
  api_1.metrics.setGlobalMeterProvider(c.meterProvider);
280
296
  }
281
297
  if (process.env.WT_PROFILING === '1') {
282
- const attrs = c.provider.resource.attributes;
298
+ const attrs = c.resource.attributes;
283
299
  c.profiler = (0, profiling_js_1.startProfiling)({
284
300
  apiKey: c.headers.Authorization.slice('Bearer '.length),
285
301
  endpoint: c.endpoint,
@@ -1 +1,3 @@
1
1
  export declare function load(id: string): unknown;
2
+ /** Load an OpenTelemetry SDK package (an optional peer); a missing one throws an error naming what to install. */
3
+ export declare function need<T>(id: string): T;
package/dist/cjs/load.js CHANGED
@@ -1,6 +1,7 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.load = load;
4
+ exports.need = need;
4
5
  // Optional-peer loader (winston-transport). This is the CommonJS form; scripts/build.mjs swaps in an ESM twin
5
6
  // (createRequire(import.meta.url)) for dist/esm. The cwd fallback only matters when neither exists (test runners).
6
7
  const node_module_1 = require("node:module");
@@ -9,3 +10,20 @@ function load(id) {
9
10
  return require(id);
10
11
  return (0, node_module_1.createRequire)(`${process.cwd()}/`)(id);
11
12
  }
13
+ const SDK_PEERS = [
14
+ '@opentelemetry/context-async-hooks', '@opentelemetry/core', '@opentelemetry/exporter-logs-otlp-http',
15
+ '@opentelemetry/exporter-metrics-otlp-http', '@opentelemetry/exporter-trace-otlp-http', '@opentelemetry/otlp-transformer',
16
+ '@opentelemetry/resources', '@opentelemetry/sdk-logs', '@opentelemetry/sdk-metrics', '@opentelemetry/sdk-trace',
17
+ ];
18
+ /** Load an OpenTelemetry SDK package (an optional peer); a missing one throws an error naming what to install. */
19
+ function need(id) {
20
+ try {
21
+ return load(id);
22
+ }
23
+ catch (e) {
24
+ if (e?.code === 'MODULE_NOT_FOUND' && String(e.message).includes(id)) {
25
+ throw new Error(`@watchtowerobservability/node needs the OpenTelemetry SDK, which is not installed (missing ${id}). Run: npm install ${SDK_PEERS.join(' ')}`);
26
+ }
27
+ throw e;
28
+ }
29
+ }
@@ -1,6 +1,5 @@
1
1
  import type { Resource } from '@opentelemetry/resources';
2
- import { MeterProvider } from '@opentelemetry/sdk-metrics';
3
- import type { PushMetricExporter } from '@opentelemetry/sdk-metrics';
2
+ import type { MeterProvider, PushMetricExporter } from '@opentelemetry/sdk-metrics';
4
3
  /** Explicit flag, else `WATCHTOWER_LOGS` / `WATCHTOWER_METRICS` (default on); `OTEL_*_EXPORTER=none` turns it off. */
5
4
  export declare function switchOn(name: string, otelExporterEnv: string, flag?: boolean): boolean;
6
5
  export interface Metrics {
@@ -40,8 +40,6 @@ exports.startMetrics = startMetrics;
40
40
  // metrics (event loop delay and utilization, GC, heap) come from the optional peer
41
41
  // @opentelemetry/instrumentation-runtime-node when it is installed.
42
42
  const nodePath = __importStar(require("node:path"));
43
- const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
44
- const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
45
43
  const buffer_js_1 = require("./buffer.js");
46
44
  const load_js_1 = require("./load.js");
47
45
  /** Explicit flag, else `WATCHTOWER_LOGS` / `WATCHTOWER_METRICS` (default on); `OTEL_*_EXPORTER=none` turns it off. */
@@ -54,20 +52,22 @@ function switchOn(name, otelExporterEnv, flag) {
54
52
  return !['off', 'false', '0', 'no'].includes((env[name] || 'on').trim().toLowerCase());
55
53
  }
56
54
  function startMetrics(endpoint, headers, resource, bufferDir, fetch, exporter) {
55
+ const sdk = (0, load_js_1.need)('@opentelemetry/sdk-metrics');
57
56
  const url = `${endpoint}/v1/metrics`;
58
57
  let exp = exporter;
59
58
  if (!exp) {
59
+ const { AggregationTemporalityPreference, OTLPMetricExporter } = (0, load_js_1.need)('@opentelemetry/exporter-metrics-otlp-http');
60
60
  const delta = process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
61
- ? {} : { temporalityPreference: exporter_metrics_otlp_http_1.AggregationTemporalityPreference.DELTA };
62
- exp = new exporter_metrics_otlp_http_1.OTLPMetricExporter({ url, headers, ...delta });
61
+ ? {} : { temporalityPreference: AggregationTemporalityPreference.DELTA };
62
+ exp = new OTLPMetricExporter({ url, headers, ...delta });
63
63
  if (bufferDir)
64
64
  exp = new buffer_js_1.MetricSpool(exp, nodePath.join(bufferDir, 'metrics'), url, headers, fetch);
65
65
  }
66
66
  const interval = Number(process.env.OTEL_METRIC_EXPORT_INTERVAL) || 60000;
67
- const reader = new sdk_metrics_1.PeriodicExportingMetricReader({
67
+ const reader = new sdk.PeriodicExportingMetricReader({
68
68
  exporter: exp, exportIntervalMillis: interval, exportTimeoutMillis: Math.min(30000, interval),
69
69
  });
70
- const provider = new sdk_metrics_1.MeterProvider({ resource, readers: [reader] });
70
+ const provider = new sdk.MeterProvider({ resource, readers: [reader] });
71
71
  let runtime;
72
72
  try {
73
73
  const mod = (0, load_js_1.load)('@opentelemetry/instrumentation-runtime-node');
@@ -1,7 +1,6 @@
1
- import type { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace-base';
1
+ import type { SpanExporter, ReadableSpan } from '@opentelemetry/sdk-trace';
2
2
  import type { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
3
- import { AggregationTemporality } from '@opentelemetry/sdk-metrics';
4
- import type { InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
3
+ import type { AggregationTemporality, InstrumentType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
5
4
  type Done = Parameters<SpanExporter['export']>[1];
6
5
  /** What the spool wraps: a span, log record or metric exporter; `B` is one export batch. */
7
6
  export interface BatchExporter<B> {
@@ -4,12 +4,12 @@
4
4
  import * as fs from 'node:fs';
5
5
  import * as path from 'node:path';
6
6
  import * as crypto from 'node:crypto';
7
- import { AggregationTemporality } from '@opentelemetry/sdk-metrics';
8
- import { JsonLogsSerializer, JsonMetricsSerializer, JsonTraceSerializer } from '@opentelemetry/otlp-transformer';
7
+ import { need } from './load.js';
8
+ const ser = () => need('@opentelemetry/otlp-transformer');
9
9
  /** OTLP/JSON encoders for the three signals. */
10
- export const encodeSpans = (spans) => Buffer.from(JsonTraceSerializer.serializeRequest(spans));
11
- export const encodeLogs = (logs) => Buffer.from(JsonLogsSerializer.serializeRequest(logs));
12
- export const encodeMetrics = (rm) => Buffer.from(JsonMetricsSerializer.serializeRequest(rm));
10
+ export const encodeSpans = (spans) => Buffer.from(ser().JsonTraceSerializer.serializeRequest(spans));
11
+ export const encodeLogs = (logs) => Buffer.from(ser().JsonLogsSerializer.serializeRequest(logs));
12
+ export const encodeMetrics = (rm) => Buffer.from(ser().JsonMetricsSerializer.serializeRequest(rm));
13
13
  export class SpoolExporter {
14
14
  inner;
15
15
  dir;
@@ -84,7 +84,7 @@ export class MetricSpool extends SpoolExporter {
84
84
  }
85
85
  selectAggregationTemporality(t) {
86
86
  const pick = this.metricInner.selectAggregationTemporality;
87
- return pick ? pick.call(this.metricInner, t) : AggregationTemporality.CUMULATIVE; // the SDK default
87
+ return pick ? pick.call(this.metricInner, t) : 1; // CUMULATIVE, the SDK default (enum value, so sdk-metrics is not imported eagerly)
88
88
  }
89
89
  forceFlush() {
90
90
  return this.metricInner.forceFlush();
@@ -1,8 +1,9 @@
1
1
  import { inspect } from 'node:util';
2
2
  import { metrics, trace } from '@opentelemetry/api';
3
3
  import type { Tracer } from '@opentelemetry/api';
4
- import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
5
- import { LoggerProvider } from '@opentelemetry/sdk-logs';
4
+ import type { Resource } from '@opentelemetry/resources';
5
+ import type { TracerProvider } from '@opentelemetry/sdk-trace';
6
+ import type { LoggerProvider } from '@opentelemetry/sdk-logs';
6
7
  import type { MeterProvider } from '@opentelemetry/sdk-metrics';
7
8
  import { captureException } from './errors.js';
8
9
  import type { CaptureContext } from './errors.js';
@@ -79,7 +80,8 @@ export declare class Client {
79
80
  };
80
81
  readonly fetch: typeof fetch;
81
82
  readonly redact: InitOptions['redact'];
82
- readonly provider: NodeTracerProvider;
83
+ readonly provider: TracerProvider;
84
+ readonly resource: Resource;
83
85
  readonly tracer: Tracer;
84
86
  readonly loggerProvider: LoggerProvider;
85
87
  readonly logger: ReturnType<LoggerProvider['getLogger']>;
package/dist/esm/index.js CHANGED
@@ -1,13 +1,8 @@
1
1
  // Thin Watchtower layer over the OpenTelemetry Node SDK: key header, endpoint default,
2
2
  // offline buffer, wt.*-safe resource attributes, redaction hook, getPrompt/score/evaluate/observe.
3
3
  import { inspect } from 'node:util';
4
- import { metrics, trace } from '@opentelemetry/api';
5
- import { Resource } from '@opentelemetry/resources';
6
- import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
7
- import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
8
- import { LoggerProvider, SimpleLogRecordProcessor, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
9
- import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
10
- import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
4
+ import { context, metrics, propagation, trace } from '@opentelemetry/api';
5
+ import { need as needPeer } from './load.js';
11
6
  import { SpoolExporter, spoolLogs } from './buffer.js';
12
7
  import { startMetrics, switchOn } from './metrics.js';
13
8
  import * as nodePath from 'node:path';
@@ -31,6 +26,7 @@ export class Client {
31
26
  fetch;
32
27
  redact;
33
28
  provider;
29
+ resource;
34
30
  tracer;
35
31
  loggerProvider;
36
32
  logger;
@@ -53,38 +49,48 @@ export class Client {
53
49
  this.fetch = o.fetch || globalThis.fetch;
54
50
  const environment = o.environment || env.WT_ENVIRONMENT;
55
51
  const release = o.release || env.WT_RELEASE;
56
- const resource = new Resource({
52
+ // the OTel SDK packages are optional peers, loaded here (not at import time) with a clear error when missing
53
+ const { resourceFromAttributes } = needPeer('@opentelemetry/resources');
54
+ const resource = resourceFromAttributes({
57
55
  'service.name': o.serviceName || env.WT_SERVICE || 'app',
58
56
  ...(environment ? { 'deployment.environment.name': environment } : {}),
59
57
  ...(release ? { 'service.version': release } : {}),
60
58
  ...safeResource(o.resource),
61
59
  });
60
+ this.resource = resource;
62
61
  this.redact = o.redact;
63
- this.provider = new NodeTracerProvider({ resource });
64
- if (o.redact)
65
- this.provider.addSpanProcessor(redactor(o.redact));
66
62
  let exporter = o.exporter;
67
63
  if (!exporter) {
68
64
  const url = `${this.endpoint}/v1/traces`;
65
+ const { OTLPTraceExporter } = needPeer('@opentelemetry/exporter-trace-otlp-http');
69
66
  exporter = new OTLPTraceExporter({ url, headers: this.headers });
70
67
  // spans and log records spool to their own subdirectories
71
68
  if (o.bufferDir)
72
69
  exporter = new SpoolExporter(exporter, nodePath.join(o.bufferDir, 'traces'), url, this.headers, this.fetch);
73
70
  }
74
- this.provider.addSpanProcessor(new BatchSpanProcessor(exporter));
71
+ // the redactor runs first, so the batch processor exports redacted attributes
72
+ const { BatchSpanProcessor, TracerProvider: TP } = needPeer('@opentelemetry/sdk-trace');
73
+ this.provider = new TP({
74
+ resource,
75
+ spanProcessors: [...(o.redact ? [redactor(o.redact)] : []), new BatchSpanProcessor({ exporter })],
76
+ });
75
77
  this.tracer = this.provider.getTracer('watchtower');
76
- this.loggerProvider = new LoggerProvider({ resource });
77
78
  const logsOn = switchOn('WATCHTOWER_LOGS', 'OTEL_LOGS_EXPORTER', o.logs);
78
79
  let logExporter = logsOn ? o.logExporter : undefined;
79
80
  if (logsOn && !logExporter && !o.exporter) {
80
81
  const url = `${this.endpoint}/v1/logs`;
82
+ const { OTLPLogExporter } = needPeer('@opentelemetry/exporter-logs-otlp-http');
81
83
  logExporter = new OTLPLogExporter({ url, headers: this.headers });
82
84
  if (o.bufferDir)
83
85
  logExporter = spoolLogs(logExporter, nodePath.join(o.bufferDir, 'logs'), url, this.headers, this.fetch);
84
86
  }
85
- if (logExporter) {
86
- this.loggerProvider.addLogRecordProcessor(o.logExporter ? new SimpleLogRecordProcessor(logExporter) : new BatchLogRecordProcessor(logExporter));
87
- }
87
+ const { LoggerProvider: LP, SimpleLogRecordProcessor, BatchLogRecordProcessor } = needPeer('@opentelemetry/sdk-logs');
88
+ this.loggerProvider = new LP({
89
+ resource,
90
+ processors: !logExporter ? [] : [o.logExporter
91
+ ? new SimpleLogRecordProcessor({ exporter: logExporter })
92
+ : new BatchLogRecordProcessor({ exporter: logExporter })],
93
+ });
88
94
  this.logger = this.loggerProvider.getLogger('watchtower');
89
95
  // with a test span exporter only an explicit metric exporter is used, as for logs
90
96
  if (switchOn('WATCHTOWER_METRICS', 'OTEL_METRICS_EXPORTER', o.metrics) && (o.metricExporter || !o.exporter)) {
@@ -230,13 +236,23 @@ export function init(opts) {
230
236
  void current?.profiler?.then((p) => p?.stop());
231
237
  const c = new Client(opts);
232
238
  current = c;
233
- c.provider.register(); // global tracer + async context so trace.getActiveSpan() works
239
+ // Global tracer + async context so trace.getActiveSpan() works; a re-init replaces the previous client's.
240
+ trace.disable();
241
+ context.disable();
242
+ propagation.disable();
243
+ const { AsyncLocalStorageContextManager } = needPeer('@opentelemetry/context-async-hooks');
244
+ const { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } = needPeer('@opentelemetry/core');
245
+ context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
246
+ propagation.setGlobalPropagator(new CompositePropagator({
247
+ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()],
248
+ }));
249
+ trace.setGlobalTracerProvider(c.provider);
234
250
  if (c.meterProvider) {
235
251
  metrics.disable(); // a re-init replaces the previous client's provider
236
252
  metrics.setGlobalMeterProvider(c.meterProvider);
237
253
  }
238
254
  if (process.env.WT_PROFILING === '1') {
239
- const attrs = c.provider.resource.attributes;
255
+ const attrs = c.resource.attributes;
240
256
  c.profiler = startProfiling({
241
257
  apiKey: c.headers.Authorization.slice('Bearer '.length),
242
258
  endpoint: c.endpoint,
@@ -1 +1,3 @@
1
1
  export declare function load(id: string): unknown;
2
+ /** Load an OpenTelemetry SDK package (an optional peer); a missing one throws an error naming what to install. */
3
+ export declare function need<T>(id: string): T;
@@ -1,6 +1,5 @@
1
1
  import type { Resource } from '@opentelemetry/resources';
2
- import { MeterProvider } from '@opentelemetry/sdk-metrics';
3
- import type { PushMetricExporter } from '@opentelemetry/sdk-metrics';
2
+ import type { MeterProvider, PushMetricExporter } from '@opentelemetry/sdk-metrics';
4
3
  /** Explicit flag, else `WATCHTOWER_LOGS` / `WATCHTOWER_METRICS` (default on); `OTEL_*_EXPORTER=none` turns it off. */
5
4
  export declare function switchOn(name: string, otelExporterEnv: string, flag?: boolean): boolean;
6
5
  export interface Metrics {
@@ -3,10 +3,8 @@
3
3
  // metrics (event loop delay and utilization, GC, heap) come from the optional peer
4
4
  // @opentelemetry/instrumentation-runtime-node when it is installed.
5
5
  import * as nodePath from 'node:path';
6
- import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
7
- import { AggregationTemporalityPreference, OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
8
6
  import { MetricSpool } from './buffer.js';
9
- import { load } from './load.js';
7
+ import { load, need } from './load.js';
10
8
  /** Explicit flag, else `WATCHTOWER_LOGS` / `WATCHTOWER_METRICS` (default on); `OTEL_*_EXPORTER=none` turns it off. */
11
9
  export function switchOn(name, otelExporterEnv, flag) {
12
10
  if (flag !== undefined)
@@ -17,9 +15,11 @@ export function switchOn(name, otelExporterEnv, flag) {
17
15
  return !['off', 'false', '0', 'no'].includes((env[name] || 'on').trim().toLowerCase());
18
16
  }
19
17
  export function startMetrics(endpoint, headers, resource, bufferDir, fetch, exporter) {
18
+ const sdk = need('@opentelemetry/sdk-metrics');
20
19
  const url = `${endpoint}/v1/metrics`;
21
20
  let exp = exporter;
22
21
  if (!exp) {
22
+ const { AggregationTemporalityPreference, OTLPMetricExporter } = need('@opentelemetry/exporter-metrics-otlp-http');
23
23
  const delta = process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
24
24
  ? {} : { temporalityPreference: AggregationTemporalityPreference.DELTA };
25
25
  exp = new OTLPMetricExporter({ url, headers, ...delta });
@@ -27,10 +27,10 @@ export function startMetrics(endpoint, headers, resource, bufferDir, fetch, expo
27
27
  exp = new MetricSpool(exp, nodePath.join(bufferDir, 'metrics'), url, headers, fetch);
28
28
  }
29
29
  const interval = Number(process.env.OTEL_METRIC_EXPORT_INTERVAL) || 60000;
30
- const reader = new PeriodicExportingMetricReader({
30
+ const reader = new sdk.PeriodicExportingMetricReader({
31
31
  exporter: exp, exportIntervalMillis: interval, exportTimeoutMillis: Math.min(30000, interval),
32
32
  });
33
- const provider = new MeterProvider({ resource, readers: [reader] });
33
+ const provider = new sdk.MeterProvider({ resource, readers: [reader] });
34
34
  let runtime;
35
35
  try {
36
36
  const mod = load('@opentelemetry/instrumentation-runtime-node');
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@watchtowerobservability/node",
3
- "version": "0.4.0",
3
+ "version": "0.5.0",
4
4
  "repository": {
5
5
  "type": "git",
6
6
  "url": "git+https://github.com/watchtowerobservability/watchtower-node.git"
@@ -350,7 +350,7 @@
350
350
  },
351
351
  "license": "Apache-2.0",
352
352
  "engines": {
353
- "node": ">=18"
353
+ "node": ">=22.15"
354
354
  },
355
355
  "scripts": {
356
356
  "build": "node scripts/build.mjs",
@@ -359,30 +359,71 @@
359
359
  "prepack": "npm run build"
360
360
  },
361
361
  "dependencies": {
362
- "@opentelemetry/api": "^1.9.0",
363
- "@opentelemetry/exporter-logs-otlp-http": "^0.57.0",
364
- "@opentelemetry/exporter-metrics-otlp-http": "^0.57.0",
365
- "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
366
- "@opentelemetry/otlp-transformer": "^0.57.0",
367
- "@opentelemetry/resources": "^1.30.0",
368
- "@opentelemetry/sdk-logs": "^0.57.0",
369
- "@opentelemetry/sdk-metrics": "^1.30.0",
370
- "@opentelemetry/sdk-trace-base": "^1.30.0",
371
- "@opentelemetry/sdk-trace-node": "^1.30.0"
362
+ "@opentelemetry/api": "^1.10.0"
372
363
  },
373
364
  "peerDependencies": {
374
- "@opentelemetry/instrumentation-runtime-node": ">=0.12.0",
365
+ "@opentelemetry/context-async-hooks": "^3.1.0",
366
+ "@opentelemetry/core": "^3.1.0",
367
+ "@opentelemetry/exporter-logs-otlp-http": "^0.301.0",
368
+ "@opentelemetry/exporter-metrics-otlp-http": "^0.301.0",
369
+ "@opentelemetry/exporter-trace-otlp-http": "^0.301.0",
370
+ "@opentelemetry/instrumentation-runtime-node": ">=0.38.0",
371
+ "@opentelemetry/otlp-transformer": "^0.301.0",
372
+ "@opentelemetry/resources": "^3.1.0",
373
+ "@opentelemetry/sdk-logs": "^3.1.0",
374
+ "@opentelemetry/sdk-metrics": "^3.1.0",
375
+ "@opentelemetry/sdk-trace": "^3.1.0",
375
376
  "winston-transport": "^4.0.0"
376
377
  },
377
378
  "peerDependenciesMeta": {
379
+ "@opentelemetry/context-async-hooks": {
380
+ "optional": true
381
+ },
382
+ "@opentelemetry/core": {
383
+ "optional": true
384
+ },
385
+ "@opentelemetry/exporter-logs-otlp-http": {
386
+ "optional": true
387
+ },
388
+ "@opentelemetry/exporter-metrics-otlp-http": {
389
+ "optional": true
390
+ },
391
+ "@opentelemetry/exporter-trace-otlp-http": {
392
+ "optional": true
393
+ },
378
394
  "@opentelemetry/instrumentation-runtime-node": {
379
395
  "optional": true
380
396
  },
397
+ "@opentelemetry/otlp-transformer": {
398
+ "optional": true
399
+ },
400
+ "@opentelemetry/resources": {
401
+ "optional": true
402
+ },
403
+ "@opentelemetry/sdk-logs": {
404
+ "optional": true
405
+ },
406
+ "@opentelemetry/sdk-metrics": {
407
+ "optional": true
408
+ },
409
+ "@opentelemetry/sdk-trace": {
410
+ "optional": true
411
+ },
381
412
  "winston-transport": {
382
413
  "optional": true
383
414
  }
384
415
  },
385
416
  "devDependencies": {
417
+ "@opentelemetry/context-async-hooks": "^3.1.0",
418
+ "@opentelemetry/core": "^3.1.0",
419
+ "@opentelemetry/exporter-logs-otlp-http": "^0.301.0",
420
+ "@opentelemetry/exporter-metrics-otlp-http": "^0.301.0",
421
+ "@opentelemetry/exporter-trace-otlp-http": "^0.301.0",
422
+ "@opentelemetry/otlp-transformer": "^0.301.0",
423
+ "@opentelemetry/resources": "^3.1.0",
424
+ "@opentelemetry/sdk-logs": "^3.1.0",
425
+ "@opentelemetry/sdk-metrics": "^3.1.0",
426
+ "@opentelemetry/sdk-trace": "^3.1.0",
386
427
  "@types/node": "22.15.0",
387
428
  "typescript": "5.7.2",
388
429
  "vitest": "5.0.5",