@ogcio/o11y-sdk-node 0.3.0 → 0.4.0

package/test/exporter/pii-exporter-decorator.test.ts

@@ -1,139 +1,88 @@
-import type { ReadableLogRecord } from "@opentelemetry/sdk-logs";
-import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import { ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import { ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { NodeSDKConfig } from "../../index.js";
-import { PIIExporterDecorator } from "../../lib/exporter/pii-exporter-decorator.js";
-import * as pii from "../../lib/internals/pii-detection.js";
-
-const mockExporter = {
-  export: vi.fn(),
-  forceFlush: vi.fn().mockResolvedValue(undefined),
-  shutdown: vi.fn().mockResolvedValue(undefined),
-  _delegate: {}, // required by OTLPExporterBase
-};
-
-const mockCallback = vi.fn();
-
-const baseSpan = (): ReadableSpan =>
-  ({
-    name: "john.doe@example.com",
-    kind: 1,
-    spanContext: () => ({ traceId: "abc", spanId: "def" }),
-    attributes: { email: "john.doe@example.com" },
-    resource: {
-      attributes: { team: "dev@example.com" },
-      otherProp: "shouldBeLost",
-    },
-    links: [{ attributes: { collaborator: "co@example.com" } }],
-    events: [{ name: "event@email.com", attributes: { code: "123" } }],
-  }) as any;
-
-const baseLog = (): ReadableLogRecord =>
-  ({
-    body: "user: john.doe@example.com",
-    attributes: { email: "john.doe@example.com" },
-    resource: {
-      attributes: { service: "log@example.com" },
-      otherProp: "shouldBeLost",
-    },
-    severityText: "INFO",
-    severityNumber: 1,
-  }) as any;
-
-vi.mock("../../lib/internals/pii-detection.js", async () => {
-  return {
-    _cleanStringPII: vi.fn((v: string) => `[REDACTED(${v})]`),
-    _cleanObjectPII: vi.fn((obj: any) =>
-      Object.fromEntries(
-        Object.entries(obj || {}).map(([k, v]) => [k, `[REDACTED(${v})]`]),
-      ),
-    ),
-    _cleanLogBodyPII: vi.fn((v: any) => `[REDACTED_BODY(${v})]`),
-  };
-});
+import { PIIExporterDecorator } from "../../lib/exporter/pii-exporter-decorator";
 
 describe("PIIExporterDecorator", () => {
-  let decorator: PIIExporterDecorator;
+  let exporterMock: any;
+  let config: any;
+  let piiExporter: PIIExporterDecorator;
 
   beforeEach(() => {
-    vi.clearAllMocks();
+    exporterMock = {
+      export: vi.fn(),
+      shutdown: vi.fn(() => Promise.resolve()),
+      forceFlush: vi.fn(() => Promise.resolve()),
+      _delegate: {},
+    };
+
+    config = { detection: { email: true } };
+    piiExporter = new PIIExporterDecorator(exporterMock, config);
   });
 
-  it("delegates forceFlush and shutdown", async () => {
-    const config: NodeSDKConfig = {};
-    decorator = new PIIExporterDecorator(mockExporter as any, config);
-
-    await decorator.forceFlush();
-    await decorator.shutdown();
-
-    expect(mockExporter.forceFlush).toHaveBeenCalled();
-    expect(mockExporter.shutdown).toHaveBeenCalled();
+  it("should redact emails in span name and attributes", () => {
+    const items: ReadableSpan[] = [
+      {
+        name: "user@example.com",
+        kind: 0,
+        spanContext: () => ({}),
+        attributes: { email: "user@example.com" },
+        resource: { attributes: { owner: "user@example.com" } },
+        events: [
+          {
+            name: "Login from user@example.com",
+            attributes: { email: "user@example.com" },
+          },
+        ],
+      } as any,
+    ];
+
+    const callback = vi.fn();
+    piiExporter.export(items, callback);
+
+    const exportedSpan = exporterMock.export.mock.calls[0][0][0];
+    expect(exportedSpan.name).toBe("[REDACTED EMAIL]");
+    expect(exportedSpan.attributes.email).toBe("[REDACTED EMAIL]");
+    expect(exportedSpan.resource.attributes.owner).toBe("[REDACTED EMAIL]");
+    expect(exportedSpan.events[0].name).toBe("Login from [REDACTED EMAIL]");
+    expect(exportedSpan.events[0].attributes.email).toBe("[REDACTED EMAIL]");
   });
 
-  it("skips redaction if detection.email is false", () => {
-    const config: NodeSDKConfig = { detection: { email: false } };
-    decorator = new PIIExporterDecorator(mockExporter as any, config);
-
-    const spans = [baseSpan()];
-    decorator.export(spans, mockCallback);
-
-    expect(mockExporter.export).toHaveBeenCalledWith(spans, mockCallback);
-    expect(pii._cleanStringPII).not.toHaveBeenCalled();
-    expect(pii._cleanObjectPII).not.toHaveBeenCalled();
+  it("should redact emails in log records", () => {
+    const items: ReadableLogRecord[] = [
+      {
+        body: "Error from user@example.com",
+        attributes: { email: "user@example.com" },
+        severityText: "INFO",
+        severityNumber: 1,
+        resource: { attributes: { owner: "user@example.com" } },
+      } as any,
+    ];
+
+    const callback = vi.fn();
+    piiExporter.export(items, callback);
+
+    const exportedLog = exporterMock.export.mock.calls[0][0][0];
+    expect(exportedLog.body).toBe("Error from [REDACTED EMAIL]");
+    expect(exportedLog.attributes.email).toBe("[REDACTED EMAIL]");
+    expect(exportedLog.resource.attributes.owner).toBe("[REDACTED EMAIL]");
   });
 
-  it("redacts span data if detection.email is true", () => {
-    const config: NodeSDKConfig = { detection: { email: true } };
-    decorator = new PIIExporterDecorator(mockExporter as any, config);
-
-    const span = baseSpan();
-    decorator.export([span], mockCallback);
-
-    expect(pii._cleanStringPII).toHaveBeenCalled();
-    expect(pii._cleanObjectPII).toHaveBeenCalled();
-    expect(mockExporter.export).toHaveBeenCalledWith([span], mockCallback);
-
-    // verify name and nested structure were touched
-    expect(span.name).toMatch(/^\[REDACTED\(/);
-    expect(span.attributes.email).toMatch(/^\[REDACTED\(/);
-
-    // Resource is replaced with only attributes, old props lost
-    expect(span.resource).toEqual({
-      attributes: { team: "[REDACTED(dev@example.com)]" },
-    });
-
-    expect(span.events[0].name).toMatch(/^\[REDACTED\(/);
-  });
-
-  it("redacts log record data if detection.email is true", () => {
-    const config: NodeSDKConfig = { detection: { email: true } };
-    decorator = new PIIExporterDecorator(mockExporter as any, config);
-
-    const log = baseLog();
-    decorator.export([log], mockCallback);
-
-    expect(pii._cleanLogBodyPII).toHaveBeenCalled();
-    expect(pii._cleanObjectPII).toHaveBeenCalled();
-
-    expect(log.body).toMatch(/^\[REDACTED_BODY\(/);
-    expect(log.attributes.email).toMatch(/^\[REDACTED\(/);
-
-    // Resource replaced with only attributes, other props lost
-    expect(log.resource).toEqual({
-      attributes: { service: "[REDACTED(log@example.com)]" },
-    });
-  });
-
-  it("handles a mix of spans and logs", () => {
-    const config: NodeSDKConfig = { detection: { email: true } };
-    decorator = new PIIExporterDecorator(mockExporter as any, config);
-
-    const items = [baseSpan(), baseLog()];
-    decorator.export(items, mockCallback);
-
-    expect(mockExporter.export).toHaveBeenCalledWith(items, mockCallback);
-    expect(pii._cleanLogBodyPII).toHaveBeenCalled();
-    expect(pii._cleanStringPII).toHaveBeenCalled();
-    expect(pii._cleanObjectPII).toHaveBeenCalled();
+  it("should redact emails in resource metrics", () => {
+    const metrics: ResourceMetrics = {
+      resource: {
+        attributes: { maintainer: "user@example.com" },
+      },
+      scopeMetrics: [],
+    } as any;
+
+    const callback = vi.fn();
+    piiExporter.export(metrics, callback);
+
+    const exportedMetric = exporterMock.export.mock.calls[0][0];
+    expect(exportedMetric.resource.attributes.maintainer).toBe(
+      "[REDACTED EMAIL]",
+    );
   });
 });

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

@@ -2,8 +2,9 @@ import { describe, expect, it, vi, beforeEach } from "vitest";
 import {
   _cleanStringPII,
   _cleanLogBodyPII,
-} from "../../lib/internals/pii-detection.js";
+} from "../../lib/internals/redaction/pii-detection.js";
 import * as sharedMetrics from "../../lib/internals/shared-metrics.js";
+import { emailRedactor } from "../../lib/internals/redaction/redactors/email";
 
 describe("PII Detection Utils", () => {
   const mockMetricAdd = vi.fn();
@@ -16,9 +17,9 @@ describe("PII Detection Utils", () => {
   });
 
   describe("_cleanStringPII", () => {
-    it("redacts plain email", () => {
+    it("redacts plain PII", () => {
       const input = "admin@example.com";
-      const output = _cleanStringPII(input, "log");
+      const output = _cleanStringPII(input, "log", [emailRedactor]);
 
       expect(output).toBe("[REDACTED EMAIL]");
       expect(mockMetricAdd).toHaveBeenCalledWith(
@@ -31,9 +32,9 @@ describe("PII Detection Utils", () => {
       );
     });
 
-    it("redacts email in URL-encoded string", () => {
+    it("redacts PII in URL-encoded string", () => {
       const input = "user%40gmail.com";
-      const output = _cleanStringPII(input, "log");
+      const output = _cleanStringPII(input, "log", [emailRedactor]);
 
       expect(output).toBe("[REDACTED EMAIL]");
       expect(mockMetricAdd).toHaveBeenCalledWith(
@@ -45,9 +46,9 @@ describe("PII Detection Utils", () => {
       );
     });
 
-    it("handles strings without email unchanged", () => {
+    it("handles strings without PII unchanged", () => {
       const input = "hello world";
-      const output = _cleanStringPII(input, "log");
+      const output = _cleanStringPII(input, "log", [emailRedactor]);
 
       expect(output).toBe("hello world");
       expect(mockMetricAdd).not.toHaveBeenCalled();
@@ -55,23 +56,25 @@ describe("PII Detection Utils", () => {
 
     it("handles array of strings", () => {
       const input = ["one@gmail.com", "two@example.com"];
-      const output = _cleanStringPII(input, "log");
+      const output = _cleanStringPII(input, "log", [emailRedactor]);
 
       expect(output).toEqual(["[REDACTED EMAIL]", "[REDACTED EMAIL]"]);
       expect(mockMetricAdd).toHaveBeenCalledTimes(2);
     });
 
     it("ignores non-string input", () => {
-      expect(_cleanStringPII(1234, "trace")).toBe(1234);
-      expect(_cleanStringPII(true, "trace")).toBe(true);
-      expect(_cleanStringPII(undefined, "trace")).toBeUndefined();
+      expect(_cleanStringPII(1234, "trace", [emailRedactor])).toBe(1234);
+      expect(_cleanStringPII(true, "trace", [emailRedactor])).toBe(true);
+      expect(
+        _cleanStringPII(undefined, "trace", [emailRedactor]),
+      ).toBeUndefined();
       expect(mockMetricAdd).not.toHaveBeenCalled();
     });
   });
 
   describe("_cleanLogBodyPII", () => {
-    it("cleans string email", () => {
-      const result = _cleanLogBodyPII("demo@abc.com");
+    it("cleans string PII", () => {
+      const result = _cleanLogBodyPII("demo@abc.com", [emailRedactor]);
       expect(result).toBe("[REDACTED EMAIL]");
     });
 
@@ -86,7 +89,7 @@ describe("PII Detection Utils", () => {
         status: "active",
       };
 
-      const result = _cleanLogBodyPII(input);
+      const result = _cleanLogBodyPII(input, [emailRedactor]);
 
       expect(result).toEqual({
         user: {
@@ -102,7 +105,7 @@ describe("PII Detection Utils", () => {
     it("cleans Uint8Array input", () => {
       const str = "admin@gmail.com";
       const buffer = new TextEncoder().encode(str);
-      const result = _cleanLogBodyPII(buffer);
+      const result = _cleanLogBodyPII(buffer, [emailRedactor]);
       const decoded = new TextDecoder().decode(result as Uint8Array);
 
       expect(decoded).toBe("[REDACTED EMAIL]");
@@ -110,7 +113,7 @@ describe("PII Detection Utils", () => {
 
     it("skips malformed Uint8Array decode", () => {
       const corrupted = new Uint8Array([0xff, 0xfe, 0xfd]);
-      const result = _cleanLogBodyPII(corrupted);
+      const result = _cleanLogBodyPII(corrupted, [emailRedactor]);
 
       // Should return a Uint8Array, but unmodified/redaction should not happen
       expect(result).toBeInstanceOf(Uint8Array);
@@ -118,11 +121,10 @@ describe("PII Detection Utils", () => {
     });
 
     it("cleans arrays of values", () => {
-      const result = _cleanLogBodyPII([
-        "bob@abc.com",
-        123,
-        { nested: "jane@example.com" },
-      ]);
+      const result = _cleanLogBodyPII(
+        ["bob@abc.com", 123, { nested: "jane@example.com" }],
+        [emailRedactor],
+      );
 
       expect(result).toEqual([
         "[REDACTED EMAIL]",
@@ -132,10 +134,10 @@ describe("PII Detection Utils", () => {
     });
 
     it("passes null and boolean through", () => {
-      expect(_cleanLogBodyPII(null)).toBeNull();
-      expect(_cleanLogBodyPII(undefined)).toBeUndefined();
-      expect(_cleanLogBodyPII(true)).toBe(true);
-      expect(_cleanLogBodyPII(false)).toBe(false);
+      expect(_cleanLogBodyPII(null, [emailRedactor])).toBeNull();
+      expect(_cleanLogBodyPII(undefined, [emailRedactor])).toBeUndefined();
+      expect(_cleanLogBodyPII(true, [emailRedactor])).toBe(true);
+      expect(_cleanLogBodyPII(false, [emailRedactor])).toBe(false);
     });
   });
 });

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

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

@@ -0,0 +1,89 @@
+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]"}
+      ${"0.0.text0.0"}                                | ${"0.0.text0.0"}
+      ${"2001:0db8::1"}                               | ${"[REDACTED IPV6]"}
+      ${"::1"}                                        | ${"[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/traces/active-span.test.ts

@@ -1,5 +1,5 @@
 import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import * as piiDetection from "../../lib/internals/pii-detection.js";
+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";

package/vitest.config.ts

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

package/dist/lib/internals/pii-detection.d.ts

@@ -1,17 +0,0 @@
-import type { AnyValue } from "@opentelemetry/api-logs";
-export type PIISource = "trace" | "log" | "metric";
-/**
- * Cleans a string by redacting email addresses and emitting metrics for PII.
- *
- * If the string is URL-encoded, it will be decoded before redaction.
- * Metrics are emitted for each domain found in redacted email addresses.
- *
- * @param {string} value - The input string to sanitize.
- * @param {"trace" | "log"} source - The source context of the input, used in metrics.
- * @returns {string} The cleaned string with any email addresses replaced by `[REDACTED EMAIL]`.
- */
-export declare function _cleanStringPII(value: AnyValue, source: PIISource): AnyValue;
-export declare function _cleanObjectPII(entry: object, source: PIISource): {
-    [k: string]: AnyValue;
-};
-export declare function _cleanLogBodyPII(value: AnyValue): AnyValue;

package/dist/lib/internals/pii-detection.js

@@ -1,116 +0,0 @@
-import { _getPIICounterRedactionMetric } from "./shared-metrics.js";
-const EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@([a-zA-Z0-9.-]+\.[a-z]{2,})/gi;
-const decoder = new TextDecoder();
-const encoder = new TextEncoder();
-/**
- * Redacts all email addresses in the input string and collects metadata.
- *
- * @param {string} value The input string potentially containing email addresses.
- * @returns {{
- *   redacted: string,
- *   count: number,
- *   domains: Record<string, number>
- * }}
- *
- * An object containing:
- *   - `redacted`: the string with email addresses replaced by `[REDACTED EMAIL]`
- *   - `count`: total number of email addresses redacted
- *   - `domains`: a map of domain names to the number of times they were redacted
- */
-function _redactEmails(value) {
-    let count = 0;
-    const domains = {};
-    const redacted = value.replace(EMAIL_REGEX, (_, domain) => {
-        count++;
-        domains[domain] = (domains[domain] || 0) + 1;
-        return "[REDACTED EMAIL]";
-    });
-    return { redacted, count, domains };
-}
-/**
- * Checks whether a string contains URI-encoded components.
- *
- * @param {string} value - The string to inspect.
- * @returns {boolean} `true` if the string is encoded, `false` otherwise.
- */
-function _containsEncodedComponents(value) {
-    try {
-        return decodeURI(value) !== decodeURIComponent(value);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Cleans a string by redacting email addresses and emitting metrics for PII.
- *
- * If the string is URL-encoded, it will be decoded before redaction.
- * Metrics are emitted for each domain found in redacted email addresses.
- *
- * @param {string} value - The input string to sanitize.
- * @param {"trace" | "log"} source - The source context of the input, used in metrics.
- * @returns {string} The cleaned string with any email addresses replaced by `[REDACTED EMAIL]`.
- */
-export function _cleanStringPII(value, source) {
-    if (Array.isArray(value)) {
-        return value.map((v) => _cleanStringPII(v, source));
-    }
-    if (typeof value !== "string") {
-        return value;
-    }
-    let kind = "string";
-    let decodedValue = value;
-    if (_containsEncodedComponents(value)) {
-        decodedValue = decodeURIComponent(value);
-        kind = "url";
-    }
-    const { redacted, count, domains } = _redactEmails(decodedValue);
-    if (count > 0) {
-        for (const [domain, domainCount] of Object.entries(domains)) {
-            _getPIICounterRedactionMetric().add(domainCount, {
-                pii_type: "email",
-                redaction_source: source,
-                pii_email_domain: domain,
-                pii_format: kind,
-            });
-        }
-    }
-    return redacted;
-}
-export function _cleanObjectPII(entry, source) {
-    if (!entry) {
-        return entry;
-    }
-    return Object.fromEntries(Object.entries(entry).map(([k, v]) => [k, _cleanStringPII(v, source)]));
-}
-export function _cleanLogBodyPII(value) {
-    if (typeof value === "string") {
-        return _cleanStringPII(value, "log");
-    }
-    if (typeof value === "number" ||
-        typeof value === "boolean" ||
-        value == null) {
-        return value;
-    }
-    if (value instanceof Uint8Array) {
-        try {
-            const decoded = decoder.decode(value);
-            const sanitized = _cleanStringPII(decoded, "log");
-            return encoder.encode(sanitized);
-        }
-        catch {
-            return value;
-        }
-    }
-    if (Array.isArray(value)) {
-        return value.map(_cleanLogBodyPII);
-    }
-    if (typeof value === "object") {
-        const sanitized = {};
-        for (const [key, val] of Object.entries(value)) {
-            sanitized[key] = _cleanLogBodyPII(val);
-        }
-        return sanitized;
-    }
-    return value;
-}