@ogcio/o11y-sdk-node 0.4.1 → 0.6.0

package/test/url-sampler.test.ts

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

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

@@ -1,144 +0,0 @@
-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/test/validation.test.ts

@@ -1,103 +0,0 @@
-import type { NodeSDK } from "@opentelemetry/sdk-node";
-import { test, describe, assert, vi, expect } from "vitest";
-
-import buildNodeInstrumentation from "../lib/instrumentation.node.js";
-import { instrumentNode } from "../index.js";
-
-describe("validation config: should return without breaking the execution", () => {
-  test("should call buildNodeInstrumentation without config and skip instrumentation", async () => {
-    const consoleWarnSpy = vi
-      .spyOn(console, "warn")
-      .mockImplementation(vi.fn());
-
-    await instrumentNode();
-
-    expect(consoleWarnSpy).toHaveBeenCalled();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "observability config not set. Skipping NodeJS OpenTelemetry instrumentation.",
-    );
-  });
-
-  test("node instrumentation: url undefined", async () => {
-    let sdk: NodeSDK | undefined = undefined;
-
-    const consoleWarnSpy = vi
-      .spyOn(console, "warn")
-      .mockImplementation(vi.fn());
-    const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(vi.fn());
-
-    await expect(
-      buildNodeInstrumentation({
-        collectorUrl: undefined,
-      }).then((result) => {
-        sdk = result;
-      }),
-    ).resolves.not.toThrowError();
-
-    assert.equal(sdk, undefined);
-
-    expect(consoleWarnSpy).toHaveBeenCalled();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "collectorUrl not set. Skipping NodeJS OpenTelemetry instrumentation.",
-    );
-    expect(consoleLogSpy).not.toHaveBeenCalled();
-  });
-
-  test("node instrumentation: invalid url", async () => {
-    let sdk: NodeSDK | undefined = undefined;
-
-    const consoleErrorSpy = vi
-      .spyOn(console, "error")
-      .mockImplementation(vi.fn());
-    const consoleLogSpy = vi.spyOn(console, "log").mockImplementation(vi.fn());
-
-    await expect(
-      buildNodeInstrumentation({
-        collectorUrl: "notavalidURL",
-      }).then((result) => {
-        sdk = result;
-      }),
-    ).resolves.not.toThrowError();
-
-    assert.equal(sdk, undefined);
-
-    expect(consoleErrorSpy).toHaveBeenCalled();
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      "collectorUrl does not use a valid format. Skipping NodeJS OpenTelemetry instrumentation.",
-    );
-    expect(consoleLogSpy).not.toHaveBeenCalled();
-  });
-
-  test("node instrumentation: verify no instrumentation if exception occurs", async () => {
-    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");
-      }),
-    }));
-
-    await expect(
-      buildNodeInstrumentation({
-        collectorUrl: "https://testurl.com",
-        serviceName: "test",
-      }).then((result) => {
-        sdk = result;
-      }),
-    ).resolves.not.toThrowError();
-
-    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

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    "module": "NodeNext" /* Specify what module code is generated. */,
-    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    "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,
-    "resolveJsonModule": true
-  },
-  "exclude": ["**/test/**"]
-}

package/vitest.config.ts

@@ -1,46 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    globals: true,
-    watch: false,
-    exclude: ["**/fixtures/**", "**/dist/**"],
-    poolOptions: {
-      threads: {
-        maxThreads: 8,
-      },
-    },
-    clearMocks: true,
-    testTimeout: 30_000,
-    coverage: {
-      enabled: true,
-      provider: "v8",
-      reportsDirectory: "coverage",
-      reporter: ["lcov", "cobertura"],
-      clean: true,
-    },
-    reporters: ["default", ["junit", { outputFile: "test-report.xml" }]],
-    environment: "node",
-    pool: "threads",
-    projects: [
-      {
-        test: {
-          include: [
-            "**/test/*.test.ts",
-            "**/test/processor/**/*.test.ts",
-            "**/test/traces/**/*.test.ts",
-            "**/test/internals/**/*.test.ts",
-            "**/test/exporter/**/*.test.ts",
-          ],
-          name: "unit",
-        },
-      },
-      {
-        test: {
-          include: ["**/test/integration/*.test.ts"],
-          name: "integration",
-        },
-      },
-    ],
-  },
-});