@ogcio/o11y-sdk-node 0.4.1 → 0.6.0

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,28 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import * as piiDetection from "../../lib/internals/redaction/pii-detection.js";
-import { getActiveSpan } from "../../lib/traces.js";
-import { MockSpan } from "../utils/mock-signals.js";
-import { setNodeSdkConfig } from "../../lib/config-manager.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();
-  });
-});

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

@@ -1,340 +0,0 @@
-import { Span, SpanOptions, SpanStatusCode, trace } from "@opentelemetry/api";
-import { TraceState } from "@opentelemetry/core";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import {
-  InMemorySpanExporter,
-  SimpleSpanProcessor,
-  SpanProcessor,
-} from "@opentelemetry/sdk-trace-base";
-import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
-import { setNodeSdkConfig } from "../../lib/config-manager.js";
-import { getActiveSpan, withSpan } from "../../lib/traces.js";
-
-describe("withSpan", () => {
-  let memoryExporter: InMemorySpanExporter;
-  let spanProcessor: SpanProcessor;
-  let sdk: NodeSDK;
-
-  beforeAll(() => {
-    memoryExporter = new InMemorySpanExporter();
-    spanProcessor = new SimpleSpanProcessor(memoryExporter);
-    sdk = new NodeSDK({
-      spanProcessors: [spanProcessor],
-      instrumentations: [],
-    });
-
-    setNodeSdkConfig({
-      collectorUrl: "http://localhost:4317",
-    });
-    sdk.start();
-  });
-
-  afterEach(async () => {
-    // Flush any remaining spans
-    await spanProcessor.forceFlush();
-    // Clean up
-    memoryExporter.reset();
-  });
-
-  afterAll(async () => {
-    await sdk.shutdown();
-  });
-
-  it("should handle simple synchronous usage", async ({}) => {
-    let capturedSpan: Span;
-
-    await withSpan({
-      spanName: "test-sync-span",
-      fn: (span: Span) => {
-        capturedSpan = span;
-      },
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-sync-span");
-    expect(spans[0].status.code).toBe(SpanStatusCode.OK);
-    expect(capturedSpan).toBeTruthy();
-    expect(capturedSpan.spanContext().traceId).toBe(
-      spans[0].spanContext().traceId,
-    );
-  });
-
-  it("should handle synchronous functions that throw errors", async ({}) => {
-    const error = new Error("Sync error");
-
-    await expect(
-      withSpan({
-        spanName: "test-sync-error-span",
-        fn: () => {
-          throw error;
-        },
-      }),
-    ).rejects.toThrow(error.message);
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-sync-error-span");
-    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
-    expect(spans[0].status.message).toBe(error.message);
-    expect(spans[0].events).toHaveLength(1);
-    expect(spans[0].events[0].name).toBe("exception");
-  });
-
-  it("should handle asynchronous functions correctly", async ({}) => {
-    let capturedSpan: Span;
-
-    await withSpan({
-      spanName: "test-async-span",
-      fn: async (span: Span) => {
-        capturedSpan = span;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        return "async-result";
-      },
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-async-span");
-    expect(spans[0].status.code).toBe(SpanStatusCode.OK);
-    expect(capturedSpan).toBeTruthy();
-    expect(capturedSpan.spanContext().traceId).toBe(
-      spans[0].spanContext().traceId,
-    );
-  });
-
-  it("should handle asynchronous functions that reject", async () => {
-    const error = new Error("Async error");
-
-    await expect(
-      withSpan({
-        spanName: "test-async-error-span",
-        fn: async () => {
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          throw error;
-        },
-      }),
-    ).rejects.toThrow(error.message);
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-async-error-span");
-    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
-    expect(spans[0].status.message).toBe(error.message);
-    expect(spans[0].events).toHaveLength(1);
-    expect(spans[0].events[0].name).toBe("exception");
-  });
-
-  it("should handle non-Error exceptions", async () => {
-    const nonErrorException = { message: "Not an error object", code: 500 };
-
-    await expect(
-      withSpan({
-        spanName: "test-non-error-span",
-        fn: () => {
-          throw nonErrorException;
-        },
-      }),
-    ).rejects.toEqual(nonErrorException);
-
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
-    expect(spans[0].status.message).toBe(JSON.stringify(nonErrorException));
-    expect(spans[0].events).toHaveLength(1);
-    expect(spans[0].events[0].name).toBe("exception");
-  });
-
-  it("should ensure span is ended even when errors occur", async () => {
-    const error = new Error("Test error");
-
-    await expect(
-      withSpan({
-        spanName: "test-finally-span",
-        fn: () => {
-          throw error;
-        },
-      }),
-    ).rejects.toThrow("Test error");
-
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].ended).toBe(true);
-  });
-
-  it("should pass span options to tracer", async () => {
-    const spanOptions: SpanOptions = {
-      attributes: { "custom.attribute": "custom-value" },
-      kind: 1,
-    };
-
-    await withSpan({
-      spanName: "test-options-span",
-      spanOptions,
-      fn: () => "result",
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].attributes["custom.attribute"]).toBe("custom-value");
-    expect(spans[0].kind).toBe(1);
-  });
-
-  it("should use custom tracer name", async () => {
-    const customTracerName = "custom-tracer";
-
-    await withSpan({
-      traceName: customTracerName,
-      spanName: "test-custom-tracer-span",
-      fn: () => "result",
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-custom-tracer-span");
-    expect(spans[0].instrumentationScope.name).toBe(customTracerName);
-  });
-
-  it("should use default tracer name when not specified", async () => {
-    await withSpan({
-      spanName: "test-default-tracer-span",
-      fn: () => "result",
-    });
-
-    await spanProcessor.forceFlush();
-    const defaultSpans = memoryExporter.getFinishedSpans();
-    expect(defaultSpans).toHaveLength(1);
-    expect(defaultSpans[0].name).toBe("test-default-tracer-span");
-    expect(defaultSpans[0].instrumentationScope.name).toBe("o11y-sdk");
-
-    memoryExporter.reset();
-
-    setNodeSdkConfig({
-      collectorUrl: "",
-      serviceName: "test-service",
-      serviceVersion: "v1.0.0",
-    });
-
-    await withSpan({
-      spanName: "test-default-tracer-span",
-      fn: () => "result",
-    });
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].name).toBe("test-default-tracer-span");
-    expect(spans[0].instrumentationScope.name).toBe("test-service");
-    expect(spans[0].instrumentationScope.version).toBe("v1.0.0");
-  });
-
-  it("should allow function to interact with span context", async () => {
-    let receivedSpan: Span;
-
-    await withSpan({
-      spanName: "test-span-context",
-      fn: (span: Span) => {
-        receivedSpan = span;
-        span.spanContext().traceState = new TraceState(
-          "alpha=aaaaaaaaaaaa,bravo=bbbbbbbbbbbb",
-        );
-      },
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(1);
-    expect(receivedSpan).toBeTruthy();
-    expect(receivedSpan.spanContext().traceId).toBe(
-      spans[0].spanContext().traceId,
-    );
-    expect(receivedSpan.spanContext().spanId).toBe(
-      spans[0].spanContext().spanId,
-    );
-    expect(spans[0].spanContext().traceState.serialize()).toStrictEqual(
-      "alpha=aaaaaaaaaaaa,bravo=bbbbbbbbbbbb",
-    );
-  });
-
-  it("should preserve context across setTimeout", async () => {
-    await withSpan({
-      spanName: "test-timeout-context",
-      fn: async (span: Span) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            getActiveSpan().addEvent("promise-resolved", {
-              result: "timeout-result",
-            });
-            resolve("timeout-result");
-          }, 10);
-        });
-      },
-    });
-
-    let newSpan: Span;
-    await trace
-      .getTracer("some-tracer")
-      .startActiveSpan("other-context", async (span) => {
-        newSpan = span;
-        span.addEvent("other-context-event", {
-          result: "other-context-result",
-        });
-      });
-
-    newSpan.addEvent("another-context-event", {
-      result: "another-context-result",
-    });
-    newSpan.setStatus({ code: SpanStatusCode.OK });
-    newSpan.end();
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(2);
-
-    const timeoutSpan = spans.find((s) => s.name === "test-timeout-context");
-    expect(timeoutSpan.status.code).toBe(SpanStatusCode.OK);
-    expect(timeoutSpan.events).toHaveLength(1);
-    expect(timeoutSpan.events[0].name).toStrictEqual("promise-resolved");
-
-    const otherTrackedSpan = spans.find((s) => s.name === "other-context");
-    expect(otherTrackedSpan.status.code).toBe(SpanStatusCode.OK);
-    expect(otherTrackedSpan.events).toHaveLength(2);
-    expect(otherTrackedSpan.events[0].name).toStrictEqual(
-      "other-context-event",
-    );
-    expect(otherTrackedSpan.events[1].name).toStrictEqual(
-      "another-context-event",
-    );
-  });
-
-  it("should handle nested spans correctly", async () => {
-    await withSpan({
-      spanName: "outer-span",
-      fn: async () => {
-        await withSpan({
-          spanName: "inner-span",
-          fn: async () => {
-            await new Promise((resolve) => setTimeout(resolve, 1));
-          },
-        });
-      },
-    });
-
-    await spanProcessor.forceFlush();
-    const spans = memoryExporter.getFinishedSpans();
-    expect(spans).toHaveLength(2);
-
-    const innerSpan = spans.find((s) => s.name === "inner-span");
-    const outerSpan = spans.find((s) => s.name === "outer-span");
-
-    expect(innerSpan).toBeTruthy();
-    expect(outerSpan).toBeTruthy();
-    expect(innerSpan!.parentSpanContext.spanId).toBe(
-      outerSpan!.spanContext().spanId,
-    );
-  });
-});