@ogcio/o11y-sdk-node 0.2.0 → 0.3.1

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

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

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

@@ -40,6 +40,13 @@ export function parseLog(
       // Additional metadata at the end, store it separately
       jsonObject["metadata"] = line;
     }
+
+    if (line.includes("Body:")) {
+      const match = line.match(/Body:\s+(\w+)\((.+)\)/);
+      if (match) {
+        jsonObject["log_body"] = match[2];
+      }
+    }
   });
 
   return jsonObject;

package/test/utils/mock-signals.ts

@@ -0,0 +1,144 @@
+import type {
+  Span,
+  SpanContext,
+  AttributeValue,
+  SpanStatus,
+  TimeInput,
+  Link,
+  Exception,
+  Attributes,
+  TraceState,
+} from "@opentelemetry/api";
+
+export class MockSpan implements Span {
+  public attributes: Record<string, AttributeValue> = {};
+  public events: {
+    name: string;
+    attributes?: Attributes | TimeInput;
+    startTime?: TimeInput;
+  }[] = [];
+  public links: Link[] = [];
+  public status?: SpanStatus;
+  public updatedName?: string;
+  public ended: boolean = false;
+  public endTime?: TimeInput;
+  public exceptions: { exception: Exception; time?: TimeInput }[] = [];
+
+  public resource: { attributes: Attributes } = { attributes: {} };
+
+  spanContext(): SpanContext {
+    return {
+      traceId: "test-trace-id",
+      spanId: "test-span-id",
+      traceFlags: 1,
+    };
+  }
+
+  setAttribute(key: string, value: AttributeValue): this {
+    this.attributes[key] = value;
+    return this;
+  }
+
+  setAttributes(attributes: Attributes): this {
+    Object.assign(this.attributes, attributes);
+    return this;
+  }
+
+  addEvent(
+    name: string,
+    attributesOrStartTime?: Attributes | TimeInput,
+    startTime?: TimeInput,
+  ): this {
+    this.events.push({ name, attributes: attributesOrStartTime, startTime });
+    return this;
+  }
+
+  addLink(link: Link): this {
+    this.links.push(link);
+    return this;
+  }
+
+  addLinks(links: Link[]): this {
+    this.links.push(...links);
+    return this;
+  }
+
+  setStatus(status: SpanStatus): this {
+    this.status = status;
+    return this;
+  }
+
+  updateName(name: string): this {
+    this.updatedName = name;
+    return this;
+  }
+
+  end(endTime?: TimeInput): void {
+    this.ended = true;
+    this.endTime = endTime;
+  }
+
+  isRecording(): boolean {
+    return true;
+  }
+
+  recordException(exception: Exception, time?: TimeInput): void {
+    this.exceptions.push({ exception, time });
+  }
+
+  reset(): void {
+    this.attributes = {};
+    this.events = [];
+    this.links = [];
+    this.status = undefined;
+    this.updatedName = undefined;
+    this.ended = false;
+    this.endTime = undefined;
+    this.exceptions = [];
+    this.resource = { attributes: {} };
+  }
+}
+
+export class TestTraceState implements TraceState {
+  private entries: Map<string, string>;
+
+  constructor(initEntries?: [string, string][]) {
+    this.entries = new Map(initEntries ?? []);
+  }
+
+  set(key: string, value: string): TraceState {
+    const newEntries: [string, string][] = [[key, value]];
+    for (const [k, v] of this.entries.entries()) {
+      if (k !== key) {
+        newEntries.push([k, v]);
+      }
+    }
+    return new TestTraceState(newEntries);
+  }
+
+  unset(key: string): TraceState {
+    const newEntries: [string, string][] = [];
+    for (const [k, v] of this.entries.entries()) {
+      if (k !== key) {
+        newEntries.push([k, v]);
+      }
+    }
+    return new TestTraceState(newEntries);
+  }
+
+  get(key: string): string | undefined {
+    return this.entries.get(key);
+  }
+
+  serialize(): string {
+    return Array.from(this.entries)
+      .slice(0, 32) // Enforce 32-member max
+      .map(([key, value]) => `${key}=${value}`)
+      .join(",");
+  }
+
+  // Optional: for testing/debugging
+  toJSON(): Record<string, string> {
+    return Object.fromEntries(this.entries);
+  }
+}

package/vitest.config.ts

@@ -25,7 +25,13 @@ export default defineConfig({
     projects: [
       {
         test: {
-          include: ["**/test/*.test.ts", "**/test/processor/*.test.ts"],
+          include: [
+            "**/test/*.test.ts",
+            "**/test/processor/*.test.ts",
+            "**/test/traces/*.test.ts",
+            "**/test/internals/*.test.ts",
+            "**/test/exporter/*.test.ts",
+          ],
           name: "unit",
         },
       },