@ogcio/o11y-sdk-node 0.1.0-beta.2 → 0.1.0-beta.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.0-beta.3](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@0.1.0-beta.2...@ogcio/o11y-sdk-node@v0.1.0-beta.3) (2025-01-28)
+
+
+### Features
+
+* **sdk-node:** custom metrics ([#53](https://github.com/ogcio/o11y/issues/53)) ([3cb40b1](https://github.com/ogcio/o11y/commit/3cb40b1add3d80615c8d123d233724094559c7ff))
+
 ## [0.1.0-beta.2](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@0.1.0-beta.1...@ogcio/o11y-sdk-node@0.1.0-beta.2) (2024-11-28)
 
 

package/README.md

@@ -27,9 +27,6 @@ import("@ogcio/o11y-sdk-node/lib/index").then((sdk) =>
   sdk.instrumentNode({
     serviceName: "node-microservice",
     collectorUrl: "http://localhost:4317",
-    collectorMode: "single",
-    enableFS: true,
-    diagLogLevel: "DEBUG",
   }),
 );
 ```
@@ -42,18 +39,106 @@ Or setup inside your package.json
 
 ```json
 {
- "main": "dist/index.js",
- "type": "module",
- "scripts": {
-    "start": "node --env-file=.env --import ./dist/instrumentation.js dist/index.js",
-  },
- ....
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node --env-file=.env --import ./dist/instrumentation.js dist/index.js"
+  }
 }
 ```
 
+## Sending Custom Metrics
+
+This package gives the possibility to send custom metrics and define them as desired in the code, you can choose between sync metrics and observable async metrics.
+
+To use this functionality, you only need to import `getMetric` and enable the application instrumentation.
+
+```typescript
+import { getMetric } from "@ogcio/o11y-sdk-node";
+```
+
+### Sync
+
+Sync metrics are signals sent when the function has been called.
+
+Creating a counter, there are 2 types of counter:
+
+- **counter** a simple counter that can only add positive numbers
+- **updowncounter** counter that support also negative numbers
+
+```typescript
+const counter = getMetric("counter", {
+  attributeName: "counter",
+  metricName: "fastify-counter",
+});
+
+counter.add(1, {
+  my: "my",
+  custom: "custom",
+  attributes: "attributes",
+});
+```
+
+Creating a Histogram
+
+```typescript
+const histogram = getMetric("histogram", {
+  metricName: "response_duration",
+  attributeName: "http_response",
+  options: {
+    advice: {
+      explicitBucketBoundaries: [0, 100, 200, 500, 1000],
+    },
+    description: "Response durations",
+  },
+});
+
+histogram.record(120, { path: "/home" });
+```
+
+### Async
+
+Async metrics are called by the scraper collector to read current data using the `Observable` pattern.
+Creating an async metric means that the application will subscribe to the observability URL and record data on call (default 60s).
+
+_keep in mind, you can't send signals on-demand with this component_
+
+Creating an async Gauge
+
+```typescript
+const asyncGauge = getMetric("async-gauge", {
+  metricName: "cpu_usage",
+  attributeName: "server_load",
+  options: { unit: "percentage" },
+}).addCallback((observer) => {
+  observer.observe(50, { host: "server1" });
+});
+```
+
+Creating an async Counter
+
+```typescript
+getMetric("async-counter", {
+  attributeName: "scraped-memory",
+  metricName: "fastify-counter",
+}).addCallback((observer) => {
+  observer.observe(freemem(), {
+    "application.os.memory": "free-memory",
+  });
+});
+```
+
 ## API Reference
 
-### Shared Types
+#### Protocol
+
+protocol is a string parameter used to define how to send signals to observability infrastructure
+
+- **grpc** Use gRPC protocol, usually default port use 4317. Is the most performant option for server side applications.
+- **http** Use HTTP standard protocol, usually default port use 4318. Mainly used on web or UI client applications.
+- **console** Used for debugging sending signals to observability cluster, every information will be printed to your runtime console.
+
+#### Shared Types
 
 ```ts
 export type SDKLogLevel =
@@ -75,3 +160,4 @@ export type SDKLogLevel =
 | `diagLogLevel`  | `SDKLogLevel`     | Diagnostic log level for the internal runtime instrumentation                                            |
 | `collectorMode` | `single \| batch` | Signals sending mode, default is batch for performance                                                   |
 | `enableFS`      | `boolean`         | Flag to enable or disable the tracing for node:fs module                                                 |
+| `protocol`      | `string`          | Type of the protocol used to send signals                                                                |

package/index.ts

@@ -5,3 +5,5 @@ import buildNodeInstrumentation from "./lib/instrumentation.node.js";
 export type * from "./lib/index.js";
 export type { NodeSDKConfig, NodeSDK };
 export { buildNodeInstrumentation as instrumentNode };
+
+export * from "./lib/metrics.js";

package/lib/console.ts

@@ -0,0 +1,15 @@
+import type { NodeSDKConfig } from "./index.js";
+import type { Exporters } from "./options.js";
+import { logs, metrics, tracing } from "@opentelemetry/sdk-node";
+
+export default function buildConsoleExporters(_: NodeSDKConfig): Exporters {
+  return {
+    traces: new tracing.ConsoleSpanExporter(),
+    metrics: new metrics.PeriodicExportingMetricReader({
+      exporter: new metrics.ConsoleMetricExporter(),
+    }),
+    logs: [
+      new logs.SimpleLogRecordProcessor(new logs.ConsoleLogRecordExporter()),
+    ],
+  };
+}

package/lib/grpc.ts

@@ -1,11 +1,11 @@
 import type { NodeSDKConfig } from "./index.js";
 import type { Exporters } from "./options.js";
 import { LogRecordProcessorMap } from "./utils.js";
+import { metrics } from "@opentelemetry/sdk-node";
 import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
 
 export default function buildGrpcExporters(config: NodeSDKConfig): Exporters {
   return {
@@ -13,7 +13,7 @@ export default function buildGrpcExporters(config: NodeSDKConfig): Exporters {
       url: `${config.collectorUrl}`,
       compression: CompressionAlgorithm.GZIP,
     }),
-    metrics: new PeriodicExportingMetricReader({
+    metrics: new metrics.PeriodicExportingMetricReader({
       exporter: new OTLPMetricExporter({
         url: `${config.collectorUrl}`,
         compression: CompressionAlgorithm.GZIP,

package/lib/http.ts

@@ -1,11 +1,11 @@
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import type { NodeSDKConfig } from "./index.js";
 import type { Exporters } from "./options.js";
 import { LogRecordProcessorMap } from "./utils.js";
+import { metrics } from "@opentelemetry/sdk-node";
 import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 
 export default function buildHttpExporters(config: NodeSDKConfig): Exporters {
   if (config.collectorUrl.endsWith("/")) {
@@ -17,7 +17,7 @@ export default function buildHttpExporters(config: NodeSDKConfig): Exporters {
       url: `${config.collectorUrl}/v1/traces`,
       compression: CompressionAlgorithm.GZIP,
     }),
-    metrics: new PeriodicExportingMetricReader({
+    metrics: new metrics.PeriodicExportingMetricReader({
       exporter: new OTLPMetricExporter({
         url: `${config.collectorUrl}/v1/metrics`,
         compression: CompressionAlgorithm.GZIP,

package/lib/index.ts

@@ -36,7 +36,7 @@ export interface NodeSDKConfig extends SDKConfig {
   enableFS?: boolean;
 
   /**
-   * http based connection protocol used to send signals.
+   * protocol used to send signals.
    *
    * @default grpc
    */
@@ -45,7 +45,7 @@ export interface NodeSDKConfig extends SDKConfig {
 
 export type SDKCollectorMode = "single" | "batch";
 
-export type SDKProtocol = "grpc" | "http";
+export type SDKProtocol = "grpc" | "http" | "console";
 
 export type SDKLogLevel =
   | "NONE"

package/lib/instrumentation.node.ts

@@ -1,12 +1,14 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
+import { NodeSDK, resources } from "@opentelemetry/sdk-node";
 import type { NodeSDKConfig } from "./index.js";
 import type { Exporters } from "./options.js";
 import isUrl from "is-url";
 import buildHttpExporters from "./http.js";
 import buildGrpcExporters from "./grpc.js";
+import buildConsoleExporters from "./console.js";
 import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import packageJson from "../package.json" with { type: "json" };
 
 export default function buildNodeInstrumentation(
   config?: NodeSDKConfig,
@@ -36,6 +38,8 @@ export default function buildNodeInstrumentation(
 
   if (config.protocol === "http") {
     exporter = buildHttpExporters(config);
+  } else if (config.protocol === "console") {
+    exporter = buildConsoleExporters(config);
   } else {
     exporter = buildGrpcExporters(config);
   }
@@ -49,6 +53,10 @@ export default function buildNodeInstrumentation(
     );
 
     const sdk = new NodeSDK({
+      resource: new resources.Resource({
+        "o11y.sdk.name": packageJson.name,
+        "o11y.sdk.version": packageJson.version,
+      }),
       serviceName: config.serviceName,
       traceExporter: exporter.traces,
       metricReader: exporter.metrics,

package/lib/metrics.ts

@@ -0,0 +1,70 @@
+import {
+  Counter,
+  createNoopMeter,
+  Gauge,
+  Histogram,
+  Meter,
+  MetricOptions,
+  metrics,
+  ObservableCounter,
+  ObservableGauge,
+  ObservableUpDownCounter,
+  UpDownCounter,
+} from "@opentelemetry/api";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare const MetricsMap: {
+  gauge: Gauge;
+  histogram: Histogram;
+  counter: Counter;
+  updowncounter: UpDownCounter;
+  "async-counter": ObservableCounter;
+  "async-updowncounter": ObservableUpDownCounter;
+  "async-gauge": ObservableGauge;
+};
+
+type MetricType = keyof typeof MetricsMap;
+
+const MetricsFactoryMap: {
+  [K in MetricType]: (
+    meter: Meter,
+  ) => (name: string, options?: MetricOptions) => (typeof MetricsMap)[K];
+} = {
+  gauge: (meter: Meter) => meter.createGauge,
+  histogram: (meter: Meter) => meter.createHistogram,
+  counter: (meter: Meter) => meter.createCounter,
+  updowncounter: (meter: Meter) => meter.createUpDownCounter,
+  "async-counter": (meter: Meter) => meter.createObservableCounter,
+  "async-updowncounter": (meter: Meter) => meter.createObservableUpDownCounter,
+  "async-gauge": (meter: Meter) => meter.createObservableGauge,
+};
+
+export interface MetricsParams {
+  metricName: string;
+  attributeName: string;
+  options?: MetricOptions;
+}
+
+function getMeter({ metricName, attributeName }: MetricsParams) {
+  let meter: Meter;
+  if (!metricName || !attributeName) {
+    console.error("Invaid metric configuration!");
+    meter = createNoopMeter();
+  } else {
+    meter = metrics.getMeter(`custom_metric.${metricName}`);
+  }
+  return meter;
+}
+
+export function getMetric<T extends MetricType>(
+  type: T,
+  p: MetricsParams,
+): (typeof MetricsMap)[T] {
+  const meter = getMeter(p);
+
+  if (!MetricsFactoryMap[type]) {
+    throw new Error(`Unsupported metric type: ${type}`);
+  }
+
+  return MetricsFactoryMap[type](meter).bind(meter)(p.attributeName, p.options);
+}

package/lib/options.ts

@@ -1,8 +1,7 @@
-import type { MetricReader } from "@opentelemetry/sdk-metrics";
-import type { logs, tracing } from "@opentelemetry/sdk-node";
+import type { logs, tracing, metrics } from "@opentelemetry/sdk-node";
 
 export type Exporters = {
   traces: tracing.SpanExporter;
-  metrics: MetricReader;
+  metrics: metrics.MetricReader;
   logs: logs.LogRecordProcessor[];
 };

package/package.json

@@ -1,13 +1,9 @@
 {
   "name": "@ogcio/o11y-sdk-node",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.3",
   "description": "Opentelemetry standard instrumentation SDK for NodeJS based project",
   "main": "dist/index.js",
   "type": "module",
-  "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
-    "test": "vitest"
-  },
   "exports": {
     ".": "./dist/index.js",
     "./*": "./dist/*.js"
@@ -24,26 +20,30 @@
   "license": "ISC",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.53.0",
-    "@opentelemetry/core": "1.28.0",
-    "@opentelemetry/exporter-logs-otlp-grpc": "^0.55.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.55.0",
-    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.55.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.55.0",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.55.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.55.0",
-    "@opentelemetry/instrumentation": "^0.55.0",
-    "@opentelemetry/otlp-exporter-base": "^0.55.0",
-    "@opentelemetry/sdk-metrics": "^1.28.0",
-    "@opentelemetry/sdk-node": "^0.55.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.55.3",
+    "@opentelemetry/core": "1.30.1",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.57.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.57.1",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.57.1",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.1",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.57.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.1",
+    "@opentelemetry/instrumentation": "^0.57.1",
+    "@opentelemetry/otlp-exporter-base": "^0.57.1",
+    "@opentelemetry/sdk-metrics": "^1.30.1",
+    "@opentelemetry/sdk-node": "^0.57.1",
     "is-url": "^1.2.4"
   },
   "devDependencies": {
     "@types/is-url": "^1.2.32",
-    "@types/node": "^22.10.0",
-    "@vitest/coverage-v8": "^2.1.6",
+    "@types/node": "^22.12.0",
+    "@vitest/coverage-v8": "^3.0.4",
     "tsx": "^4.19.2",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.6"
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "vitest"
   }
-}
+}

package/test/metrics.test.ts

@@ -0,0 +1,142 @@
+import { describe, test, expect, vi, beforeEach, assert } from "vitest";
+import { getMetric, MetricsParams } from "../lib/metrics";
+
+const mockMeter = {
+  createGauge: vi.fn(),
+  createHistogram: vi.fn(),
+  createCounter: vi.fn(),
+  createUpDownCounter: vi.fn(),
+  createObservableCounter: vi.fn(),
+  createObservableUpDownCounter: vi.fn(),
+  createObservableGauge: vi.fn(),
+};
+
+vi.mock("@opentelemetry/api", async () => {
+  const { createNoopMeter } = await import("@opentelemetry/api");
+
+  return {
+    metrics: {
+      getMeter: vi.fn(() => mockMeter),
+    },
+    createNoopMeter: createNoopMeter,
+  };
+});
+
+describe("MetricsFactoryMap", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const validMetricParams: MetricsParams = {
+    metricName: "test-metric",
+    attributeName: "test-attribute",
+    options: { description: "A test metric" },
+  };
+
+  test("should call createGauge when type is 'gauge'", () => {
+    mockMeter.createGauge.mockReturnValue("mocked-gauge");
+
+    const result = getMetric("gauge", validMetricParams);
+
+    expect(result).toBe("mocked-gauge");
+    expect(mockMeter.createGauge).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createHistogram when type is 'histogram'", () => {
+    mockMeter.createHistogram.mockReturnValue("mocked-histogram");
+
+    const result = getMetric("histogram", validMetricParams);
+
+    expect(result).toBe("mocked-histogram");
+    expect(mockMeter.createHistogram).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createCounter when type is 'counter'", () => {
+    mockMeter.createCounter.mockReturnValue("mocked-counter");
+
+    const result = getMetric("counter", validMetricParams);
+
+    expect(result).toBe("mocked-counter");
+    expect(mockMeter.createCounter).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createUpDownCounter when type is 'updowncounter'", () => {
+    mockMeter.createUpDownCounter.mockReturnValue("mocked-updowncounter");
+
+    const result = getMetric("updowncounter", validMetricParams);
+
+    expect(result).toBe("mocked-updowncounter");
+    expect(mockMeter.createUpDownCounter).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createObservableCounter when type is 'async-counter'", () => {
+    mockMeter.createObservableCounter.mockReturnValue("mocked-async-counter");
+
+    const result = getMetric("async-counter", validMetricParams);
+
+    expect(result).toBe("mocked-async-counter");
+    expect(mockMeter.createObservableCounter).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createObservableUpDownCounter when type is 'async-updowncounter'", () => {
+    mockMeter.createObservableUpDownCounter.mockReturnValue(
+      "mocked-async-updowncounter",
+    );
+
+    const result = getMetric("async-updowncounter", validMetricParams);
+
+    expect(result).toBe("mocked-async-updowncounter");
+    expect(mockMeter.createObservableUpDownCounter).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should call createObservableGauge when type is 'async-gauge'", () => {
+    mockMeter.createObservableGauge.mockReturnValue("mocked-async-gauge");
+
+    const result = getMetric("async-gauge", validMetricParams);
+
+    expect(result).toBe("mocked-async-gauge");
+    expect(mockMeter.createObservableGauge).toHaveBeenCalledWith(
+      validMetricParams.attributeName,
+      validMetricParams.options,
+    );
+  });
+
+  test("should throw an error for unsupported metric types", () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const invalidMetricType = "invalid-type" as any;
+
+    expect(() => getMetric(invalidMetricType, validMetricParams)).toThrow(
+      `Unsupported metric type: ${invalidMetricType}`,
+    );
+  });
+
+  test("should return noop metric fallback for null config", async () => {
+    const nullMetricParams: MetricsParams = {
+      metricName: null!,
+      attributeName: "",
+    };
+
+    const result = getMetric("async-gauge", nullMetricParams);
+
+    assert.isNotNull(result);
+    assert.equal(result.constructor.name, "NoopObservableGaugeMetric");
+  });
+});

package/test/node-config.test.ts

@@ -1,6 +1,6 @@
 import { test, describe, assert, expect } from "vitest";
 import buildNodeInstrumentation from "../lib/instrumentation.node.js";
-import { NodeSDK, logs } from "@opentelemetry/sdk-node";
+import { NodeSDK, logs, metrics, tracing } from "@opentelemetry/sdk-node";
 import { OTLPTraceExporter as GRPC_OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
 import { OTLPMetricExporter as GRPC_OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
 import { OTLPLogExporter as GRPC_OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
@@ -32,10 +32,7 @@ describe("verify config settings", () => {
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
     const traceExporter = _configuration.traceExporter;
-    assert.equal(
-      traceExporter["_transport"]["_parameters"]["compression"],
-      "gzip",
-    );
+
     assert.ok(traceExporter instanceof GRPC_OTLPTraceExporter);
 
     const logRecordProcessors = _configuration.logRecordProcessors;
@@ -64,10 +61,6 @@ describe("verify config settings", () => {
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
     const traceExporter = _configuration.traceExporter;
-    assert.equal(
-      traceExporter._transport._transport._parameters.compression,
-      "gzip",
-    );
     assert.ok(traceExporter instanceof HTTP_OTLPTraceExporter);
 
     const logRecordProcessors = _configuration.logRecordProcessors;
@@ -82,6 +75,39 @@ describe("verify config settings", () => {
     assert.ok(metricReader._exporter instanceof HTTP_OTLPMetricExporter);
   });
 
+  test("console - console config", () => {
+    const config: NodeSDKConfig = {
+      ...commonConfig,
+      protocol: "console",
+      diagLogLevel: "NONE",
+    };
+
+    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    assert.ok(sdk);
+
+    const _configuration = sdk["_configuration"];
+    assert.equal(_configuration.serviceName, commonConfig.serviceName);
+
+    const traceExporter = _configuration.traceExporter;
+
+    assert.ok(traceExporter instanceof tracing.ConsoleSpanExporter);
+    assert.isUndefined(traceExporter._transport);
+
+    const logRecordProcessors = _configuration.logRecordProcessors;
+    assert.equal(logRecordProcessors.length, 1);
+
+    assert.ok(logRecordProcessors[0] instanceof logs.SimpleLogRecordProcessor);
+    assert.ok(
+      logRecordProcessors[0]["_exporter"] instanceof
+        logs.ConsoleLogRecordExporter,
+    );
+    assert.isUndefined(logRecordProcessors[0]["_exporter"]._transport);
+
+    const metricReader = _configuration.metricReader;
+    assert.ok(metricReader._exporter instanceof metrics.ConsoleMetricExporter);
+    assert.isUndefined(metricReader._exporter._transport);
+  });
+
   test("single log sending config", () => {
     const config: NodeSDKConfig = {
       ...commonConfig,

package/test/validation.test.ts

@@ -63,4 +63,35 @@ describe("validation config: should return without breaking the execution", () =
     );
     expect(consoleLogSpy).not.toHaveBeenCalled();
   });
+
+  test("node instrumentation: verify no instrumentation if exception occurs", () => {
+    let sdk: NodeSDK | undefined = undefined;
+
+    const consoleErrorSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(vi.fn());
+    const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(vi.fn());
+
+    vi.mock("@opentelemetry/auto-instrumentations-node", () => ({
+      getNodeAutoInstrumentations: vi.fn(() => {
+        throw new Error("Wanted error");
+      }),
+    }));
+
+    assert.doesNotThrow(() => {
+      sdk = buildNodeInstrumentation({
+        collectorUrl: "https://testurl.com",
+        serviceName: "test",
+      });
+    });
+
+    assert.equal(sdk, undefined);
+
+    expect(consoleErrorSpy).toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Error starting NodeJS OpenTelemetry instrumentation:",
+      new Error("Wanted error"),
+    );
+    expect(consoleLogSpy).not.toHaveBeenCalled();
+  });
 });

package/tsconfig.json

@@ -8,7 +8,8 @@
     "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
     "strict": true /* Enable all strict type-checking options. */,
     "skipLibCheck": true /* Skip type checking all .d.ts files. */,
-    "declaration": true
+    "declaration": true,
+    "resolveJsonModule": true
   },
   "exclude": ["**/test/**"]
 }