@ogcio/o11y-sdk-node 0.4.1 → 0.6.0

package/test/internals/pii-detection.test.ts

@@ -1,265 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import {
-  _cleanStringPII,
-  _containsEncodedComponents,
-  _recursiveObjectClean,
-} from "../../lib/internals/redaction/pii-detection.js";
-import * as sharedMetrics from "../../lib/internals/shared-metrics.js";
-import { emailRedactor } from "../../lib/internals/redaction/redactors/email";
-import { ipRedactor } from "../../lib/internals/redaction/redactors/ip";
-
-describe("PII Detection Utils", () => {
-  const mockMetricAdd = vi.fn();
-
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.spyOn(sharedMetrics, "_getPIICounterRedactionMetric").mockReturnValue({
-      add: mockMetricAdd,
-    });
-  });
-
-  describe("_cleanStringPII", () => {
-    it("redacts plain PII", () => {
-      const input = "admin@example.com";
-      const output = _cleanStringPII(input, "log", [emailRedactor]);
-
-      expect(output).toBe("[REDACTED EMAIL]");
-      expect(mockMetricAdd).toHaveBeenCalledWith(
-        1,
-        expect.objectContaining({
-          pii_email_domain: "example.com",
-          pii_type: "email",
-          redaction_source: "log",
-        }),
-      );
-    });
-
-    it("redacts email in URL-encoded string", () => {
-      const input = "user%40gmail.com";
-      const output = _cleanStringPII(input, "log", [emailRedactor]);
-
-      expect(output).toBe("[REDACTED EMAIL]");
-      expect(mockMetricAdd).toHaveBeenCalledWith(
-        1,
-        expect.objectContaining({
-          pii_format: "url",
-          pii_email_domain: "gmail.com",
-        }),
-      );
-    });
-
-    it("redacts ip in URL-encoded string", () => {
-      const input = "%20127.0.0.1";
-      const output = _cleanStringPII(input, "log", [ipRedactor]);
-
-      expect(output).toBe(" [REDACTED IPV4]");
-      expect(mockMetricAdd).toHaveBeenCalledWith(
-        1,
-        expect.objectContaining({
-          pii_format: "url",
-          pii_type: "IPv4",
-          redaction_source: "log",
-        }),
-      );
-    });
-
-    it("handles strings without PII unchanged", () => {
-      const input = "hello world";
-      const output = _cleanStringPII(input, "log", [emailRedactor]);
-
-      expect(output).toBe("hello world");
-      expect(mockMetricAdd).not.toHaveBeenCalled();
-    });
-
-    it("ignores non-string input", () => {
-      // @ts-expect-error
-      expect(_cleanStringPII(1234, "trace", [emailRedactor])).toBe(1234);
-      // @ts-expect-error
-      expect(_cleanStringPII(true, "trace", [emailRedactor])).toBe(true);
-      expect(
-        _cleanStringPII(undefined, "trace", [emailRedactor]),
-      ).toBeUndefined();
-      expect(mockMetricAdd).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("_recursiveObjectClean", () => {
-    it("cleans string PII", () => {
-      const result = _recursiveObjectClean("demo@abc.com", "log", [
-        emailRedactor,
-      ]);
-      expect(result).toBe("[REDACTED EMAIL]");
-    });
-
-    it("cleans array of strings", () => {
-      const input = ["one@gmail.com", "two@example.com"];
-      const output = _recursiveObjectClean(input, "log", [emailRedactor]);
-
-      expect(output).toEqual(["[REDACTED EMAIL]", "[REDACTED EMAIL]"]);
-      expect(mockMetricAdd).toHaveBeenCalledTimes(2);
-    });
-
-    it("cleans deeply nested object", () => {
-      const input = {
-        user: {
-          email: "test@gmail.com",
-          profile: {
-            contact: "foo@example.com",
-          },
-        },
-        status: "active",
-      };
-
-      const result = _recursiveObjectClean(input, "log", [emailRedactor]);
-
-      expect(result).toEqual({
-        user: {
-          email: "[REDACTED EMAIL]",
-          profile: {
-            contact: "[REDACTED EMAIL]",
-          },
-        },
-        status: "active",
-      });
-    });
-
-    it("cleans Uint8Array input", () => {
-      const str = "admin@gmail.com";
-      const buffer = new TextEncoder().encode(str);
-      const result = _recursiveObjectClean(buffer, "log", [emailRedactor]);
-      const decoded = new TextDecoder().decode(result as Uint8Array);
-
-      expect(decoded).toBe("[REDACTED EMAIL]");
-    });
-
-    it("skips malformed Uint8Array decode", () => {
-      const corrupted = new Uint8Array([0xff, 0xfe, 0xfd]);
-      const result = _recursiveObjectClean(corrupted, "log", [emailRedactor]);
-
-      // Should return a Uint8Array, but unmodified/redaction should not happen
-      expect(result).toBeInstanceOf(Uint8Array);
-      expect(result).not.toEqual(expect.arrayContaining([91, 82, 69]));
-    });
-
-    it("cleans arrays of values", () => {
-      const result = _recursiveObjectClean(
-        ["bob@abc.com", 123, { nested: "jane@example.com" }],
-        "log",
-        [emailRedactor],
-      );
-
-      expect(result).toEqual([
-        "[REDACTED EMAIL]",
-        123,
-        { nested: "[REDACTED EMAIL]" },
-      ]);
-    });
-
-    it("passes null and boolean through", () => {
-      expect(_recursiveObjectClean(null, "log", [emailRedactor])).toBeNull();
-      expect(
-        _recursiveObjectClean(undefined, "log", [emailRedactor]),
-      ).toBeUndefined();
-      expect(_recursiveObjectClean(true, "log", [emailRedactor])).toBe(true);
-      expect(_recursiveObjectClean(false, "log", [emailRedactor])).toBe(false);
-    });
-  });
-
-  describe("_containsEncodedComponents", () => {
-    describe("should return true for properly URL encoded strings", () => {
-      it.each([
-        ["hello%20world", "Space encoded as %20"],
-        ["test%2Bvalue", "Plus sign encoded as %2B"],
-        ["path%2Fto%2Ffile", "Forward slashes encoded"],
-        ["user%40domain.com", "@ symbol encoded"],
-        ["100%25%20off", "Percent and space encoded"],
-        ["a%3Db%26c%3Dd", "Query parameters (a=b&c=d)"],
-        ["caf%C3%A9", "UTF-8 encoded (café)"],
-        ["price%3A%20%2410", "Colon, space, dollar ($10)"],
-        ["%22quoted%22", "Double quotes encoded"],
-        ["https%3A%2F%2Fexample.com", "Full URL encoded"],
-        ["file%20name.txt", "filename encoded"],
-        ["search%3Fq%3Dhello%20world", "Query string encoded"],
-        ["%3C%3E%26%22%27", "HTML special chars encoded (<>&\"')"],
-        ["%E2%9C%93", "UTF-8 checkmark (✓) encoded"],
-        ["test%2b", "Lowercase hex"],
-        ["%E4%B8%AD%E6%96%87", "Chinese characters encoded"],
-      ])('should detect "%s" as URL encoded (%s)', (input, description) => {
-        expect(_containsEncodedComponents(input)).toBe(true);
-      });
-    });
-
-    describe("should return false for non-URL encoded strings", () => {
-      it.each([
-        ["test", "Simple ASCII string"],
-        ["hello world", "Unencoded space"],
-        ["user@domain.com", "Unencoded email"],
-        ["simple123", "Alphanumeric only"],
-        ["", "Empty string"],
-        ["25%%", "Literal percent signs"],
-        ["100% off", "Percent without hex digits"],
-        ["test%2", "Incomplete percent encoding"],
-        ["hello%ZZ", "Invalid hex digits"],
-        ["test%2G", "Invalid hex digit G"],
-        ["bad%encoding%here", "Percent without hex pairs"],
-        ["hello%20world and more", "Partially encoded string"],
-        ["hello%20world%21%20how%20are%20you", "Overly encoded string"],
-        ["café", "Unicode characters (unencoded)"],
-        ["hello+world", "Plus sign (form encoding style)"],
-        ["test%", "Trailing percent"],
-        ["hello%20world%", "Encoded content with trailing percent"],
-        ["%", "Single percent"],
-        ["%%", "Double percent"],
-        ["normal text with % symbols", "Text with percent but no encoding"],
-        ["price: $100%", "Currency with percent"],
-        ["file.txt", "Simple filename"],
-        ["path/to/file", "Unencoded path"],
-        ["query?param=value", "Unencoded query string"],
-        ["hello%world", "Percent without following hex"],
-        ["test%1", "Single hex digit after percent"],
-        ["hello%zz", "Non-hex characters after percent"],
-      ])('should not detect "%s" as URL encoded (%s)', (input, description) => {
-        expect(_containsEncodedComponents(input)).toBe(false);
-      });
-    });
-
-    describe("Error handling", () => {
-      it.each([
-        ["%C0%80", "Overlong UTF-8 encoding (security concern)"],
-        ["%ED%A0%80", "UTF-8 surrogate (invalid)"],
-        ["%FF%FE", "Invalid UTF-8 sequence"],
-        ["test%20%ZZ", "Mix of valid and invalid encoding"],
-      ])('should handle "%s" (%s)', (input, description) => {
-        // These should not throw errors
-        expect(() => _containsEncodedComponents(input)).not.toThrow();
-
-        // Most of these should return false due to invalid sequences
-        // or security-related encoding issues
-        const result = _containsEncodedComponents(input);
-        expect(typeof result).toBe("boolean");
-      });
-    });
-
-    describe("real-world url examples", () => {
-      it.each([
-        [
-          "https%3A%2F%2Fgoogle.com%2Fsearch%3Fq%3Djavascript",
-          "Encoded Google search URL",
-        ],
-        ["The%20quick%20brown%20fox", "Sentence with spaces encoded"],
-        [
-          "/api/user?body=here%20are%20all%20my%20secrets",
-          "contextually encoded API path",
-        ],
-        ["redirect_uri=https%3A%2F%2Fapp.com%2Fcallback", "OAuth redirect URI"],
-        ["data%3Atext%2Fplain%3Bbase64%2CSGVsbG8%3D", "Data URL encoded"],
-      ])('real-world case: "%s" (%s)', (input, description) => {
-        const result = _containsEncodedComponents(input);
-
-        // Verify the function doesn't crash
-        expect(typeof result).toBe("boolean");
-        expect(result).toBe(true);
-      });
-    });
-  });
-});

package/test/internals/redactors/email.test.ts

@@ -1,81 +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";
-import { emailRedactor } from "../../../lib/internals/redaction/redactors/email";
-
-describe("Email 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 = "admin@example.com";
-      const output = emailRedactor(input, "log", "string");
-
-      expect(output).toBe("[REDACTED EMAIL]");
-      expect(mockMetricAdd).toHaveBeenCalledWith(
-        1,
-        expect.objectContaining({
-          pii_email_domain: "example.com",
-          pii_type: "email",
-          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 email addresses", () => {
-    beforeAll(() => {
-      vi.spyOn(sharedMetrics, "_getPIICounterRedactionMetric").mockReturnValue({
-        add: vi.fn(),
-      });
-    });
-
-    afterAll(() => {
-      vi.restoreAllMocks();
-    });
-
-    it.each`
-      value                                  | expectedRedactedValue
-      ${"user+tag@example.com"}              | ${"[REDACTED EMAIL]"}
-      ${"user.name+tag+sorting@example.com"} | ${"[REDACTED EMAIL]"}
-      ${"x@example.museum"}                  | ${"[REDACTED EMAIL]"}
-      ${"a.b-c_d@example.co.uk"}             | ${"[REDACTED EMAIL]"}
-      ${"üser@example.de"}                   | ${"[REDACTED EMAIL]"}
-      ${"john.doe@xn--exmple-cua.com"}       | ${"[REDACTED EMAIL]"}
-      ${"üser@example.de"}                   | ${"[REDACTED EMAIL]"}
-      ${"plainaddress"}                      | ${"plainaddress"}
-      ${"@missinglocal.org"}                 | ${"@missinglocal.org"}
-      ${"user@invalid_domain.com"}           | ${"user@invalid_domain.com"}
-    `(
-      "returns $expectedRedactedValue for value '$value'",
-      async ({ value, expectedRedactedValue }: Record<string, string>) => {
-        const result = emailRedactor(value, "log", "string");
-        expect(result).toBe(expectedRedactedValue);
-      },
-    );
-  });
-});

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");
-  });
-});