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

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, vi } 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/url-sampler.test.ts

@@ -0,0 +1,215 @@
+import { Context } from "@opentelemetry/api";
+import {
+  SamplingDecision,
+  SamplingResult,
+} from "@opentelemetry/sdk-trace-base";
+import { describe, expect, test, vi } from "vitest";
+import { UrlSampler } from "../lib/url-sampler";
+
+describe("url sampler", () => {
+  // mock sampler to be sure every trace after UrlSamper has RECORD status
+  const mockSampler = {
+    shouldSample: vi
+      .fn()
+      .mockImplementation(
+        (_context, _traceId, _spanName, _spanKind, attributes, _links) => {
+          return {
+            decision: SamplingDecision.RECORD,
+            attributes: attributes,
+          } as SamplingResult;
+        },
+      ),
+  };
+
+  test("should add custom span attributes to trace", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+      {
+        "signal.namespace": "unittest",
+        "signal.callback.result": () => "test",
+      },
+    );
+
+    expect(sampler).not.toBeNull();
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/track" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+    expect(result.attributes).not.toBeNull();
+  });
+
+  test("should not record trace about /health api", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+    );
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/health" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("should record every other trace which is not /health api", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+    );
+
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/test" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/another/url" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+  });
+
+  test("operator 'includes', should not record every trace which include /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "includes",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("operator 'endsWith', should not record only trace which ends with /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    // expect traced with block in the URL middle
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    // should stop trace with block at the end
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/example/block" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("operator 'equals', should not record trace which is equal to /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "equals",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/block" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+});

package/test/utils/alloy-log-parser.ts

@@ -0,0 +1,46 @@
+export function parseLog(
+  log: string,
+): Record<string, object | string | number> {
+  const logArray = log
+    .split("\\n")
+    .map((line) => line.trim())
+    .filter((line) => line);
+
+  const jsonObject: Record<string, object | string | number> = {};
+  let currentSection: Record<string, object | string | number> = jsonObject;
+  const sectionStack: Record<string, object | string | number>[] = [];
+
+  logArray.forEach((line) => {
+    line = line.trim();
+
+    if (line.startsWith("->")) {
+      const match = line.match(/->\s+([^:]+):\s+(Str|Int)\((.+)\)/);
+      if (match) {
+        const [, key, type, value] = match;
+        const parsedValue = type === "Int" ? parseInt(value, 10) : value;
+
+        if (typeof currentSection === "object") {
+          currentSection[key] = parsedValue;
+        }
+      }
+    } else if (line.endsWith(":")) {
+      // new section
+      const sectionName = line
+        .slice(0, -1)
+        .trim()
+        .toLowerCase()
+        .replace(" ", "_");
+      jsonObject[sectionName] = {};
+      currentSection = jsonObject[sectionName] as Record<
+        string,
+        object | string | number
+      >;
+      sectionStack.push(currentSection);
+    } else if (line.startsWith('"')) {
+      // Additional metadata at the end, store it separately
+      jsonObject["metadata"] = line;
+    }
+  });
+
+  return jsonObject;
+}

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/**"]
 }

package/vitest.config.ts

@@ -4,7 +4,6 @@ export default defineConfig({
   test: {
     globals: true,
     watch: false,
-    include: ["**/test/*.test.ts"],
     exclude: ["**/fixtures/**", "**/dist/**"],
     poolOptions: {
       threads: {
@@ -22,5 +21,20 @@ export default defineConfig({
     },
     reporters: ["default", ["junit", { outputFile: "test-report.xml" }]],
     environment: "node",
+    pool: "threads",
+    workspace: [
+      {
+        test: {
+          include: ["**/test/*.test.ts", "**/test/processor/*.test.ts"],
+          name: "unit",
+        },
+      },
+      {
+        test: {
+          include: ["**/test/integration/*.test.ts"],
+          name: "integration",
+        },
+      },
+    ],
   },
 });