@ogcio/o11y-sdk-node 0.4.2 → 0.6.1

package/test/internals/redactors/ip.test.ts

@@ -1,93 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  vi,
-  beforeEach,
-  beforeAll,
-  afterAll,
-} from "vitest";
-
-import * as sharedMetrics from "../../../lib/internals/shared-metrics.js";
-import { ipRedactor } from "../../../lib/internals/redaction/redactors/ip";
-
-describe("IP Redaction utils", () => {
-  describe("tracks metrics", () => {
-    const mockMetricAdd = vi.fn();
-
-    beforeEach(() => {
-      vi.restoreAllMocks();
-      vi.spyOn(sharedMetrics, "_getPIICounterRedactionMetric").mockReturnValue({
-        add: mockMetricAdd,
-      });
-    });
-
-    it("redacts plain PII and tracks redaction with metric", () => {
-      const input = "255.255.255.255";
-      const output = ipRedactor(input, "log", "string");
-
-      expect(output).toBe("[REDACTED IPV4]");
-      expect(mockMetricAdd).toHaveBeenCalledWith(
-        1,
-        expect.objectContaining({
-          pii_format: "string",
-          pii_type: "IPv4",
-          redaction_source: "log",
-        }),
-      );
-    });
-
-    it("handles strings without PII unchanged", () => {
-      const input = "hello world";
-      const output = ipRedactor(input, "log", "string");
-
-      expect(output).toBe("hello world");
-      expect(mockMetricAdd).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("Redacts IPv4 and IPv6", () => {
-    beforeAll(() => {
-      vi.spyOn(sharedMetrics, "_getPIICounterRedactionMetric").mockReturnValue({
-        add: vi.fn(),
-      });
-    });
-
-    afterAll(() => {
-      vi.restoreAllMocks();
-    });
-
-    it.each`
-      value                                           | expectedRedactedValue
-      ${"hello world"}                                | ${"hello world"}
-      ${"hello 127.0.0.1"}                            | ${"hello [REDACTED IPV4]"}
-      ${"127.0.0.1, hello!"}                          | ${"[REDACTED IPV4], hello!"}
-      ${"127.0.0.1,127.0.0.1"}                        | ${"[REDACTED IPV4],[REDACTED IPV4]"}
-      ${"127.0.0.1127.0.0.1"}                         | ${"127.0.0.1127.0.0.1"}
-      ${"256.1.1.1"}                                  | ${"256.1.1.1"}
-      ${"0.0.0.0!"}                                   | ${"[REDACTED IPV4]!"}
-      ${"text0.0.0.0"}                                | ${"text[REDACTED IPV4]"}
-      ${"%A00.0.0.0"}                                 | ${"[REDACTED IPV4]"}
-      ${"0.0.0.0%20"}                                 | ${"[REDACTED IPV4]"}
-      ${"0.0.text0.0"}                                | ${"0.0.text0.0"}
-      ${"2001:0db8::1"}                               | ${"[REDACTED IPV6]"}
-      ${"::1"}                                        | ${"[REDACTED IPV6]"}
-      ${"%20::1"}                                     | ${"[REDACTED IPV6]"}
-      ${"::1%A0"}                                     | ${"[REDACTED IPV6]"}
-      ${"text::1"}                                    | ${"text[REDACTED IPV6]"}
-      ${"::1text"}                                    | ${"[REDACTED IPV6]text"}
-      ${"sentence ending with f::1"}                  | ${"sentence ending with [REDACTED IPV6]"}
-      ${"sentence ending with :::1"}                  | ${"sentence ending with :::1"}
-      ${"2001:0DB8:85A3:0000:0000:8A2E:0370:7334::1"} | ${"2001:0DB8:85A3:0000:0000:8A2E:0370:7334::1"}
-      ${"2001:0DB8:85A3:0000:text:8A2E:0370:7334"}    | ${"2001:0DB8:85A3:0000:text:8A2E:0370:7334"}
-      ${"2001:0db8::12001:0db8::1"}                   | ${"2001:0db8::12001:0db8::1"}
-      ${"2001:0db8::1,2001:0db8::1"}                  | ${"[REDACTED IPV6],[REDACTED IPV6]"}
-    `(
-      "returns $expectedRedactedValue for value '$value'",
-      async ({ value, expectedRedactedValue }: Record<string, string>) => {
-        const result = ipRedactor(value, "log", "string");
-        expect(result).toBe(expectedRedactedValue);
-      },
-    );
-  });
-});

package/test/internals/shared-metrics.test.ts

@@ -1,34 +0,0 @@
-vi.mock("../../lib/metrics", () => {
-  return {
-    getMetric: vi.fn(),
-  };
-});
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { _getPIICounterRedactionMetric } from "../../lib/internals/shared-metrics.js";
-import { getMetric } from "../../lib/metrics"; // Get the mocked function
-
-describe("shared metrics", () => {
-  const mockMetric = { add: vi.fn() };
-
-  beforeEach(() => {
-    vi.resetModules(); // Clear module-level cache
-    vi.restoreAllMocks();
-    (getMetric as vi.Mock).mockClear(); // clear call history
-    (getMetric as vi.Mock).mockReturnValue(mockMetric);
-  });
-
-  it("calls getMetric with correct arguments and caches result", () => {
-    const metric1 = _getPIICounterRedactionMetric();
-    const metric2 = _getPIICounterRedactionMetric();
-
-    expect(getMetric).toHaveBeenCalledOnce();
-    expect(getMetric).toHaveBeenCalledWith("counter", {
-      meterName: "o11y",
-      metricName: "o11y_pii_redaction",
-    });
-
-    expect(metric1).toBe(mockMetric);
-    expect(metric2).toBe(mockMetric); // should be cached
-  });
-});

package/test/metrics.test.ts

@@ -1,142 +0,0 @@
-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,190 +0,0 @@
-import { NodeSDK, metrics } from "@opentelemetry/sdk-node";
-import { afterAll, assert, describe, expect, test } from "vitest";
-import buildNodeInstrumentation from "../lib/instrumentation.node.js";
-
-import {
-  BatchLogRecordProcessor,
-  SimpleLogRecordProcessor,
-} from "@opentelemetry/sdk-logs";
-import {
-  BatchSpanProcessor,
-  SimpleSpanProcessor,
-} from "@opentelemetry/sdk-trace-base";
-import buildHttpExporters from "../lib/exporter/http.js";
-import { NodeSDKConfig } from "../lib/index.js";
-import { EnrichLogProcessor } from "../lib/processor/enrich-logger-processor.js";
-import { EnrichSpanProcessor } from "../lib/processor/enrich-span-processor.js";
-import { PIIExporterDecorator } from "../lib/exporter/pii-exporter-decorator.js";
-
-describe("verify config settings", () => {
-  const commonConfig = {
-    collectorUrl: "https://testurl.com",
-    serviceName: "test",
-  };
-
-  test("grpc config", async () => {
-    const config: NodeSDKConfig = {
-      ...commonConfig,
-      protocol: "grpc",
-      collectorMode: "batch",
-      diagLogLevel: "NONE",
-    };
-
-    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
-
-    assert.ok(sdk);
-
-    const _configuration = sdk["_configuration"];
-    assert.equal(_configuration.serviceName, commonConfig.serviceName);
-
-    const logs = _configuration.logRecordProcessors;
-
-    assert.equal(logs.length, 1);
-    assert.ok(logs[logs.length - 1] instanceof BatchLogRecordProcessor);
-
-    const spans = _configuration.spanProcessors;
-
-    assert.equal(spans.length, 1);
-    assert.ok(spans[0] instanceof BatchSpanProcessor);
-
-    assert.ok(
-      _configuration.metricReader instanceof
-        metrics.PeriodicExportingMetricReader,
-    );
-  });
-
-  test("http config", async () => {
-    const config: NodeSDKConfig = {
-      ...commonConfig,
-      protocol: "http",
-      diagLogLevel: "NONE",
-      spanAttributes: {
-        name: "custom-value",
-      },
-    };
-
-    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
-    assert.ok(sdk);
-
-    const _configuration = sdk["_configuration"];
-    assert.equal(_configuration.serviceName, commonConfig.serviceName);
-
-    const logs = _configuration.logRecordProcessors;
-
-    assert.equal(logs.length, 2);
-    assert.ok(logs[0] instanceof EnrichLogProcessor);
-    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);
-
-    assert.ok(
-      _configuration.metricReader instanceof
-        metrics.PeriodicExportingMetricReader,
-    );
-  });
-
-  test("console - console config", async () => {
-    const config: NodeSDKConfig = {
-      ...commonConfig,
-      protocol: "console",
-      diagLogLevel: "NONE",
-      spanAttributes: {
-        name: "custom-name",
-      },
-    };
-
-    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[0] instanceof EnrichLogProcessor);
-    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", async () => {
-    const config: NodeSDKConfig = {
-      ...commonConfig,
-      protocol: "grpc",
-      diagLogLevel: "NONE",
-      collectorMode: "single",
-    };
-
-    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[logRecordProcessors.length - 1] instanceof
-        SimpleLogRecordProcessor,
-    );
-  });
-
-  test("pii exporter decorator injected by default", async () => {
-    const config: NodeSDKConfig = {
-      ...commonConfig,
-      protocol: "grpc",
-      diagLogLevel: "NONE",
-      collectorMode: "single",
-      detection: {},
-    };
-
-    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[logRecordProcessors.length - 1] instanceof
-        SimpleLogRecordProcessor,
-    );
-    assert.ok(
-      logRecordProcessors[logRecordProcessors.length - 1][
-        "_exporter"
-      ] instanceof PIIExporterDecorator,
-    );
-  });
-
-  test("check if clear base endpoint final slash", () => {
-    const config: NodeSDKConfig = {
-      collectorUrl: "http://example.com/",
-    };
-
-    buildHttpExporters(config);
-
-    expect(config.collectorUrl).toBe("http://example.com");
-  });
-
-  afterAll(() => {
-    // shutdown every instrumentation
-    process.emit("SIGTERM");
-  });
-});

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

@@ -1,58 +0,0 @@
-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

@@ -1,52 +0,0 @@
-import { Context } from "@opentelemetry/api";
-import { describe, expect, it } from "vitest";
-import { EnrichSpanProcessor } from "../../lib/processor/enrich-span-processor.js";
-import { MockSpan } from "../utils/mock-signals.js";
-
-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

@@ -1,33 +0,0 @@
-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");
-  });
-});

package/test/traces/active-span.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { setNodeSdkConfig } from "../../lib/config-manager.js";
-import { getActiveSpan } from "../../lib/traces.js";
-
-describe("getActiveSpan", () => {
-  it("returns undefined if no active span", async () => {
-    setNodeSdkConfig({
-      serviceName: "unit-test",
-      collectorUrl: "http://collector",
-      detection: {
-        email: false,
-      },
-    });
-
-    // Temporarily override
-    const opentelemetry = await import("@opentelemetry/api");
-
-    vi.spyOn(opentelemetry.trace, "getActiveSpan").mockImplementationOnce(
-      () => undefined,
-    );
-
-    const span = getActiveSpan();
-
-    expect(span).toBeUndefined();
-  });
-});