@ogcio/o11y-sdk-node 0.1.0-beta.1 → 0.1.0-beta.11

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",
+    meterName: "test-meter",
+    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.metricName,
+      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.metricName,
+      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.metricName,
+      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.metricName,
+      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.metricName,
+      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.metricName,
+      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.metricName,
+      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!,
+      meterName: "",
+    };
+
+    const result = getMetric("async-gauge", nullMetricParams);
+
+    assert.isNotNull(result);
+    assert.equal(result.constructor.name, "NoopObservableGaugeMetric");
+  });
+});

package/test/node-config.test.ts

@@ -1,15 +1,18 @@
 import { test, describe, assert, expect } from "vitest";
 import buildNodeInstrumentation from "../lib/instrumentation.node.js";
-import { NodeSDK, logs } 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";
-
-import { OTLPTraceExporter as HTTP_OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPMetricExporter as HTTP_OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPLogExporter as HTTP_OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { NodeSDK, metrics } from "@opentelemetry/sdk-node";
+
 import { NodeSDKConfig } from "../lib/index.js";
-import buildHttpExporters from "../lib/http.js";
+import buildHttpExporters from "../lib/exporter/http.js";
+import {
+  BatchSpanProcessor,
+  SimpleSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import {
+  BatchLogRecordProcessor,
+  SimpleLogRecordProcessor,
+} from "@opentelemetry/sdk-logs";
+import { EnrichSpanProcessor } from "../lib/processor/enrich-span-processor.js";
 
 describe("verify config settings", () => {
   const commonConfig = {
@@ -17,72 +20,101 @@ describe("verify config settings", () => {
     serviceName: "test",
   };
 
-  test("grpc config", () => {
+  test("grpc config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "grpc",
+      collectorMode: "batch",
       diagLogLevel: "NONE",
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
 
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
-    const traceExporter = _configuration.traceExporter;
-    assert.equal(
-      traceExporter["_transport"]["_parameters"]["compression"],
-      "gzip",
-    );
-    assert.ok(traceExporter instanceof GRPC_OTLPTraceExporter);
+    const logs = _configuration.logRecordProcessors;
+
+    assert.equal(logs.length, 2);
+    assert.ok(logs[1] instanceof BatchLogRecordProcessor);
+
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    assert.ok(spans[0] instanceof BatchSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
-    const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
-    // assert default signals sending mode
-    assert.ok(logRecordProcessors[0] instanceof logs.BatchLogRecordProcessor);
     assert.ok(
-      logRecordProcessors[0]["_exporter"] instanceof GRPC_OTLPLogExporter,
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
     );
-
-    const metricReader = _configuration.metricReader;
-    assert.ok(metricReader._exporter instanceof GRPC_OTLPMetricExporter);
   });
 
-  test("http config", () => {
+  test("http config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "http",
       diagLogLevel: "NONE",
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
     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 logs = _configuration.logRecordProcessors;
+
+    assert.equal(logs.length, 2);
+    assert.ok(logs[1] instanceof BatchLogRecordProcessor);
+
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    assert.ok(spans[0] instanceof BatchSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
-    const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
-    // assert default signals sending mode
-    assert.ok(logRecordProcessors[0] instanceof logs.BatchLogRecordProcessor);
     assert.ok(
-      logRecordProcessors[0]["_exporter"] instanceof HTTP_OTLPLogExporter,
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
     );
+  });
 
-    const metricReader = _configuration.metricReader;
-    assert.ok(metricReader._exporter instanceof HTTP_OTLPMetricExporter);
+  test("console - console config", async () => {
+    const config: NodeSDKConfig = {
+      ...commonConfig,
+      protocol: "console",
+      diagLogLevel: "NONE",
+    };
+
+    const sdk: NodeSDK = await buildNodeInstrumentation(config)!;
+    assert.ok(sdk);
+
+    const _configuration = sdk["_configuration"];
+    assert.equal(_configuration.serviceName, commonConfig.serviceName);
+
+    const logs = _configuration.logRecordProcessors;
+
+    // verify simple log processor for instant console logging
+    assert.equal(logs.length, 2);
+    assert.ok(logs[1] instanceof SimpleLogRecordProcessor);
+
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    // verify simple span for instant console logging
+    assert.ok(spans[0] instanceof SimpleSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
+
+    assert.ok(
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
+    );
   });
 
-  test("single log sending config", () => {
+  test("single log sending config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "grpc",
@@ -90,15 +122,15 @@ describe("verify config settings", () => {
       collectorMode: "single",
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
 
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
 
     const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
-    assert.ok(logRecordProcessors[0] instanceof logs.SimpleLogRecordProcessor);
+    assert.equal(logRecordProcessors.length, 2);
+    assert.ok(logRecordProcessors[1] instanceof SimpleLogRecordProcessor);
   });
 
   test("check if clear base endpoint final slash", () => {

package/test/processor/enrich-logger-processor.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from "vitest";
+import { LogRecord } from "@opentelemetry/sdk-logs";
+import { EnrichLogProcessor } from "../../lib/processor/enrich-logger-processor.js";
+
+const createMockLogRecord = () => {
+  return {
+    setAttribute: vi.fn(),
+  } as unknown as LogRecord;
+};
+
+describe("EnrichLogProcessor", () => {
+  it("should enrich log record with static attributes", () => {
+    const attributes = { key1: "value1", key2: 42 };
+    const processor = new EnrichLogProcessor(attributes);
+    const mockLogRecord = createMockLogRecord();
+
+    processor.onEmit(mockLogRecord);
+
+    expect(mockLogRecord.setAttribute).toHaveBeenCalledWith("key1", "value1");
+    expect(mockLogRecord.setAttribute).toHaveBeenCalledWith("key2", 42);
+  });
+
+  it("should enrich log record with dynamic attributes", () => {
+    const attributes = {
+      key1: () => "dynamicValue",
+      key2: () => 100,
+    };
+    const processor = new EnrichLogProcessor(attributes);
+    const mockLogRecord = createMockLogRecord();
+
+    processor.onEmit(mockLogRecord);
+
+    expect(mockLogRecord.setAttribute).toHaveBeenCalledWith(
+      "key1",
+      "dynamicValue",
+    );
+    expect(mockLogRecord.setAttribute).toHaveBeenCalledWith("key2", 100);
+  });
+
+  it("should not set attributes if no span attributes are provided", () => {
+    const processor = new EnrichLogProcessor();
+    const mockLogRecord = createMockLogRecord();
+
+    processor.onEmit(mockLogRecord);
+
+    expect(mockLogRecord.setAttribute).not.toHaveBeenCalled();
+  });
+
+  it("should reject forceFlush", async () => {
+    await expect(
+      new EnrichLogProcessor().forceFlush(),
+    ).resolves.toBeUndefined();
+  });
+
+  it("should resolve shutdown", async () => {
+    await expect(new EnrichLogProcessor().shutdown()).resolves.toBeUndefined();
+  });
+});

package/test/processor/enrich-span-processor.test.ts

@@ -0,0 +1,104 @@
+import {
+  AttributeValue,
+  Context,
+  Exception,
+  Link,
+  Span,
+  SpanAttributes,
+  SpanContext,
+  SpanStatus,
+  TimeInput,
+} from "@opentelemetry/api";
+import { describe, expect, it } from "vitest";
+import { EnrichSpanProcessor } from "../../lib/processor/enrich-span-processor.js";
+
+class MockSpan implements Span {
+  public attributes: Record<string, AttributeValue> = {};
+
+  spanContext(): SpanContext {
+    throw new Error("Method not implemented.");
+  }
+  setAttribute(key: string, value: AttributeValue): this {
+    this.attributes[key] = value;
+    return this;
+  }
+  setAttributes(attributes: SpanAttributes): this {
+    throw new Error("Method not implemented.");
+  }
+  addEvent(
+    name: string,
+    attributesOrStartTime?: SpanAttributes | TimeInput,
+    startTime?: TimeInput,
+  ): this {
+    throw new Error("Method not implemented.");
+  }
+  addLink(link: Link): this {
+    throw new Error("Method not implemented.");
+  }
+  addLinks(links: Link[]): this {
+    throw new Error("Method not implemented.");
+  }
+  setStatus(status: SpanStatus): this {
+    throw new Error("Method not implemented.");
+  }
+  updateName(name: string): this {
+    throw new Error("Method not implemented.");
+  }
+  end(endTime?: TimeInput): void {
+    throw new Error("Method not implemented.");
+  }
+  isRecording(): boolean {
+    throw new Error("Method not implemented.");
+  }
+  recordException(exception: Exception, time?: TimeInput): void {
+    throw new Error("Method not implemented.");
+  }
+}
+
+describe("EnrichSpanProcessor", () => {
+  it("should set static attributes on span", () => {
+    const spanAttributes = {
+      key1: "value1",
+      key2: 123,
+    };
+    const processor = new EnrichSpanProcessor(spanAttributes);
+    const mockSpan = new MockSpan();
+    const mockContext = {} as Context;
+
+    processor.onStart(mockSpan, mockContext);
+
+    expect(mockSpan.attributes["key1"]).toBe("value1");
+    expect(mockSpan.attributes["key2"]).toBe(123);
+  });
+
+  it("should set dynamic attributes on span", () => {
+    const spanAttributes = {
+      dynamicKey: () => "dynamicValue",
+    };
+    const processor = new EnrichSpanProcessor(spanAttributes);
+    const mockSpan = new MockSpan();
+    const mockContext = {} as Context;
+
+    processor.onStart(mockSpan, mockContext);
+
+    expect(mockSpan.attributes["dynamicKey"]).toBe("dynamicValue");
+  });
+
+  it("should not set attributes if none are provided", () => {
+    const processor = new EnrichSpanProcessor();
+    const mockSpan = new MockSpan();
+    const mockContext = {} as Context;
+
+    processor.onStart(mockSpan, mockContext);
+
+    expect(mockSpan.attributes["key1"]).toBeUndefined();
+  });
+
+  it("default method, should maintain default behaviour", async () => {
+    const processor = new EnrichSpanProcessor();
+
+    expect(processor.onEnd(null!)).toBeUndefined();
+    expect(await processor.shutdown()).toBeUndefined();
+    expect(await processor.forceFlush()).toBeUndefined();
+  });
+});

package/test/resource.test.ts

@@ -0,0 +1,33 @@
+import { describe, test, expect } from "vitest";
+import { ObservabilityResourceDetector } from "../lib/resource";
+
+describe("ObservabilityResourceDetector", () => {
+  test("should return custom resource attribute", () => {
+    const detector = new ObservabilityResourceDetector({
+      first: "first_value",
+      second: "second_value",
+    });
+    const result = detector.detect();
+
+    expect(result.attributes).not.toBeNull();
+    expect(result.attributes).toHaveProperty("first");
+    expect(result.attributes!["first"]).eq("first_value");
+    expect(result.attributes).toHaveProperty("second");
+    expect(result.attributes!["second"]).eq("second_value");
+    // default
+    expect(result.attributes).toHaveProperty("o11y.sdk.name");
+    expect(result.attributes!["o11y.sdk.name"]).eq("@ogcio/o11y-sdk-node");
+    expect(result.attributes).toHaveProperty("o11y.sdk.version");
+  });
+
+  test("should return default resource attribute", () => {
+    const detector = new ObservabilityResourceDetector();
+    const result = detector.detect();
+
+    expect(result.attributes).not.toBeNull();
+    // default
+    expect(result.attributes).toHaveProperty("o11y.sdk.name");
+    expect(result.attributes!["o11y.sdk.name"]).eq("@ogcio/o11y-sdk-node");
+    expect(result.attributes).toHaveProperty("o11y.sdk.version");
+  });
+});