@ogcio/o11y-sdk-react 0.2.0 → 0.4.0

package/lib/internals/redaction/redactors/ip.ts

@@ -0,0 +1,78 @@
+import { faro } from "@grafana/faro-web-sdk";
+
+// Generous IP address matchers (might match some invalid addresses like 192.168.01.1)
+const IPV4_REGEX =
+  /(?<!\d)(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}(?!\d)/gi;
+const IPV6_REGEX =
+  /(?<![0-9a-f:])((?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,7}:|:(?::[0-9A-Fa-f]{1,4}){1,7}|(?:[0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,5}(?::[0-9A-Fa-f]{1,4}){1,2}|(?:[0-9A-Fa-f]{1,4}:){1,4}(?::[0-9A-Fa-f]{1,4}){1,3}|(?:[0-9A-Fa-f]{1,4}:){1,3}(?::[0-9A-Fa-f]{1,4}){1,4}|(?:[0-9A-Fa-f]{1,4}:){1,2}(?::[0-9A-Fa-f]{1,4}){1,5}|[0-9A-Fa-f]{1,4}:(?::[0-9A-Fa-f]{1,4}){1,6}|:(?::[0-9A-Fa-f]{1,4}){1,7}:?|(?:[0-9A-Fa-f]{1,4}:){1,4}:(?:25[0-5]|2[0-4]\d|1\d\d|\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|\d{1,2})){3})(?![0-9a-f:])/gi;
+
+/**
+ * Redacts all ip addresses in the input string and collects metadata.
+ *
+ * @param {string} value The input string potentially containing ip addresses.
+ * @returns {{
+ *   redacted: string,
+ *   count: number,
+ *   domains: Record<string, number>
+ * }}
+ *
+ * An object containing:
+ *   - `redacted`: the string with IP addresses replaced by `[REDACTED IPV*]`
+ *   - `counters`: total number of addresses redacted by IPv* type
+ *   - `domains`: a map of domain names to the number of times they were redacted
+ */
+function _redactIps(value: string): {
+  redacted: string;
+  counters: Record<string, number>;
+} {
+  const counters: Record<string, number> = {};
+  const redacted = value
+    .replace(IPV4_REGEX, () => {
+      counters["IPv4"] = (counters["IPv4"] || 0) + 1;
+      return "[REDACTED IPV4]";
+    })
+    .replace(IPV6_REGEX, () => {
+      counters["IPv4"] = (counters["IPv4"] || 0) + 1;
+      return "[REDACTED IPV6]";
+    });
+  return { redacted, counters };
+}
+
+/**
+ * Redacts provided input and collects metadata metrics about redacted IPs,
+ * data source and kind.
+ *
+ * @param {string} value The input string potentially containing IP addresses.
+ * @param {string} source The source of the attribute being redacted (log, span, metric).
+ * @param {string} kind The type of the data structure containing the PII
+ * @returns {string} the redacted value
+ */
+export const ipRedactor = (
+  value: string,
+  source: string,
+  kind: string,
+): string => {
+  const { redacted, counters } = _redactIps(value);
+
+  Object.entries(counters).forEach(([type, counter]) => {
+    if (counter > 0) {
+      faro.api.pushMeasurement(
+        {
+          type: "faro_o11y_pii_redaction",
+          values: {
+            redacted: counter,
+          },
+        },
+        {
+          context: {
+            pii_type: type,
+            redaction_source: source,
+            pii_format: kind,
+          },
+        },
+      );
+    }
+  });
+
+  return redacted;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogcio/o11y-sdk-react",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Opentelemetry standard instrumentation SDK for React based project",
   "main": "dist/index.js",
   "type": "module",
@@ -19,19 +19,19 @@
   "author": "team:ogcio/observability",
   "license": "ISC",
   "dependencies": {
-    "@grafana/faro-react": "^1.18.2",
-    "@grafana/faro-web-sdk": "^1.18.2",
-    "@grafana/faro-web-tracing": "^1.18.2",
+    "@grafana/faro-react": "^1.19.0",
+    "@grafana/faro-web-sdk": "^1.19.0",
+    "@grafana/faro-web-tracing": "^1.19.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "2.0.1",
-    "@opentelemetry/instrumentation-document-load": "^0.47.0",
-    "@opentelemetry/instrumentation-fetch": "^0.202.0",
-    "@opentelemetry/instrumentation-user-interaction": "^0.47.0"
+    "@opentelemetry/instrumentation-document-load": "^0.48.0",
+    "@opentelemetry/instrumentation-fetch": "^0.203.0",
+    "@opentelemetry/instrumentation-user-interaction": "^0.48.0"
   },
   "devDependencies": {
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.3.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "tsx": "^4.20.3",
+    "tsx": "^4.20.5",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/test/config.test.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import buildFaroInstrumentation from "../lib/instrumentation.faro";
+import { initializeFaro } from "@grafana/faro-react";
+import { _beforeSend } from "../lib/internals/hooks";
+import { redactors } from "../lib/internals/redaction/redactors";
+import * as detectionTools from "../lib/internals/redaction/pii-detection";
+
+// Mock dependencies
+vi.mock("@grafana/faro-react", async () => {
+  const actual = await vi.importActual<any>("@grafana/faro-react");
+  return {
+    ...actual,
+    initializeFaro: vi.fn(() => ({ fakeFaro: true })),
+    getWebInstrumentations: vi.fn(() => ["webInstrumentation"]),
+    ErrorsInstrumentation: vi.fn(() => "errorsInstrumentation"),
+    WebVitalsInstrumentation: vi.fn(() => "webVitalsInstrumentation"),
+  };
+});
+
+vi.mock("@grafana/faro-web-tracing", () => ({
+  TracingInstrumentation: vi.fn(() => "tracingInstrumentation"),
+}));
+
+vi.mock("@opentelemetry/core", () => ({
+  W3CTraceContextPropagator: vi.fn(() => "tracePropagator"),
+}));
+
+vi.mock("@opentelemetry/instrumentation-document-load", () => ({
+  DocumentLoadInstrumentation: vi.fn(() => "docLoadInstrumentation"),
+}));
+
+vi.mock("@opentelemetry/instrumentation-fetch", () => ({
+  FetchInstrumentation: vi.fn((opts) => ({
+    ...opts,
+    name: "fetchInstrumentation",
+  })),
+}));
+
+vi.mock("@opentelemetry/instrumentation-user-interaction", () => ({
+  UserInteractionInstrumentation: vi.fn(() => "userInteractionInstrumentation"),
+}));
+
+vi.mock("./internals/hooks", () => ({
+  _beforeSend: vi.fn(() => "hooked"),
+}));
+
+describe("buildFaroInstrumentation", () => {
+  const validConfig = {
+    collectorUrl: "https://valid-url.com",
+    serviceName: "test-app",
+    detection: {
+      email: true,
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    console.warn = vi.fn();
+    console.error = vi.fn();
+    console.log = vi.fn();
+  });
+
+  it("returns undefined and warns if config is not provided", () => {
+    const result = buildFaroInstrumentation();
+    expect(console.warn).toHaveBeenCalledWith(
+      "observability config not set. Skipping Faro OpenTelemetry instrumentation.",
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined and warns if collectorUrl is missing", () => {
+    const result = buildFaroInstrumentation({
+      ...validConfig,
+      collectorUrl: undefined!,
+    });
+    expect(console.warn).toHaveBeenCalledWith(
+      "collectorUrl not set. Skipping Faro OpenTelemetry instrumentation.",
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined and errors if collectorUrl is invalid", () => {
+    const result = buildFaroInstrumentation({
+      ...validConfig,
+      collectorUrl: "not-a-url",
+    });
+    expect(console.error).toHaveBeenCalledWith(
+      "collectorUrl does not use a valid format. Skipping Faro OpenTelemetry instrumentation.",
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("defaults all detection to true if not provided", () => {
+    const config = {
+      ...validConfig,
+      detection: {},
+    };
+    buildFaroInstrumentation(config);
+    expect(initializeFaro).toHaveBeenCalledOnce();
+    expect(initializeFaro.mock.calls[0][0].beforeSend.toString()).toEqual(
+      _beforeSend(Object.values(redactors)).toString(),
+    );
+  });
+
+  it("sets beforeSend if detection.email is true", () => {
+    buildFaroInstrumentation({ ...validConfig, detection: { email: true } });
+    expect(initializeFaro).toHaveBeenCalledOnce();
+    expect(initializeFaro.mock.calls[0][0].beforeSend.toString()).toEqual(
+      _beforeSend(Object.values(redactors)).toString(),
+    );
+  });
+
+  it("does not set beforeSend if detection.email is false", () => {
+    buildFaroInstrumentation({ ...validConfig, detection: { email: false } });
+    expect(initializeFaro).toHaveBeenCalledOnce();
+    expect(initializeFaro.mock.calls[0][0].beforeSend.toString()).toEqual(
+      _beforeSend(
+        Object.entries(redactors)
+          .filter(([key]) => key !== "email")
+          .map(([, redactor]) => redactor),
+      ).toString(),
+    );
+  });
+
+  it("disables batching when collectorMode is 'single'", () => {
+    buildFaroInstrumentation({ ...validConfig, collectorMode: "single" });
+    expect(initializeFaro).toHaveBeenCalledWith(
+      expect.objectContaining({
+        batching: {
+          enabled: false,
+        },
+      }),
+    );
+  });
+
+  it("sets diagLogLevel if provided", async () => {
+    const { DiagLogLevel } = await import("@opentelemetry/api");
+    const setLoggerSpy = vi
+      .spyOn(await import("@opentelemetry/api"), "diag", "get")
+      .mockReturnValue({
+        setLogger: vi.fn(),
+      });
+
+    buildFaroInstrumentation({ ...validConfig, diagLogLevel: "DEBUG" });
+
+    expect(setLoggerSpy().setLogger).toHaveBeenCalledWith(
+      expect.anything(),
+      DiagLogLevel.DEBUG,
+    );
+  });
+
+  it("handles initialization failure and logs error", () => {
+    (initializeFaro as any).mockImplementationOnce(() => {
+      throw new Error("init failed");
+    });
+
+    const result = buildFaroInstrumentation(validConfig);
+    expect(console.error).toHaveBeenCalledWith(
+      "Error starting Faro OpenTelemetry instrumentation:",
+      expect.any(Error),
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("returns the faro object on successful initialization", () => {
+    const result = buildFaroInstrumentation(validConfig);
+    expect(console.log).toHaveBeenCalledWith(
+      "Faro OpenTelemetry instrumentation started successfully.",
+    );
+    expect(result).toEqual({ fakeFaro: true });
+  });
+
+  it("skips detection if all redactors are set to false", () => {
+    const config = {
+      ...validConfig,
+      detection: Object.fromEntries(
+        Object.keys(redactors).map((key) => [key, false]),
+      ),
+    };
+
+    buildFaroInstrumentation(config);
+
+    const cleanStringMock = vi.spyOn(detectionTools, "_cleanStringPII");
+
+    expect(initializeFaro).toHaveBeenCalledOnce();
+    expect(initializeFaro.mock.calls[0][0].beforeSend).toBeTruthy();
+
+    initializeFaro.mock.calls[0][0].beforeSend({
+      type: "log",
+      payload: { name: "eventName", timestamp: "a timestamp" },
+      meta: {},
+    });
+
+    expect(cleanStringMock).not.toHaveBeenCalled();
+  });
+
+  it("handles comma-separated corsTraceHeaders", async () => {
+    buildFaroInstrumentation({
+      ...validConfig,
+      corsTraceHeaders: "https://site1.com,https://site2.com",
+    });
+
+    const { FetchInstrumentation } = await import(
+      "@opentelemetry/instrumentation-fetch"
+    );
+    expect(FetchInstrumentation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        propagateTraceHeaderCorsUrls: [
+          new RegExp("https://site1.com"),
+          new RegExp("https://site2.com"),
+        ],
+      }),
+    );
+  });
+});

package/test/lib/hooks.test.ts

@@ -0,0 +1,150 @@
+import {
+  LogEvent,
+  LogLevel,
+  TransportItem,
+  TransportItemType,
+} from "@grafana/faro-web-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { _beforeSend } from "../../lib/internals/hooks";
+
+// Mock faro.api.pushMeasurement
+vi.mock("@grafana/faro-web-sdk", async () => {
+  const actual = await vi.importActual<any>("@grafana/faro-web-sdk");
+  return {
+    ...actual,
+    faro: {
+      api: {
+        pushMeasurement: vi.fn(),
+      },
+    },
+  };
+});
+
+import { faro } from "@grafana/faro-web-sdk";
+import { redactors } from "../../lib/internals/redaction/redactors";
+
+describe("_beforeSend", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should deeply redact PII in object", () => {
+    const item = {
+      type: TransportItemType.LOG,
+      payload: {
+        level: LogLevel.INFO,
+        context: {},
+        timestamp: Date.now().toString(),
+        message: "my email is bob@abc.com",
+      },
+      meta: {
+        user: {
+          email: "carol@abc.com",
+          attributes: {
+            alternative_email: "foo@xyz.org",
+          },
+        },
+      },
+    } satisfies TransportItem<LogEvent>;
+
+    const redacted: TransportItem<LogEvent> = _beforeSend([redactors.email])(
+      item,
+    ) as TransportItem<LogEvent>;
+
+    expect(redacted.payload.message).toBe("my email is [REDACTED EMAIL]");
+    expect(redacted.meta.user).not.toBeNull();
+    expect(redacted.meta.user!.email).toBe("[REDACTED EMAIL]");
+    expect(redacted.meta.user!.attributes).toBeDefined();
+    expect(redacted.meta.user!.attributes!["alternative_email"]).toBe(
+      "[REDACTED EMAIL]",
+    );
+    expect(faro.api.pushMeasurement).toHaveBeenCalledTimes(3);
+  });
+
+  it("should redact email inside arrays of primitives", () => {
+    const item: TransportItem<LogEvent> = {
+      type: TransportItemType.LOG,
+      payload: {
+        message: "start",
+        context: {
+          messages: ["hello", "email: test@abc.com", "ok"],
+        },
+        timestamp: "123",
+        level: LogLevel.INFO,
+      },
+    };
+
+    const redacted = _beforeSend([redactors.email])(item)!;
+
+    expect(redacted.payload.context.messages[1]).toBe(
+      "email: [REDACTED EMAIL]",
+    );
+    expect(faro.api.pushMeasurement).toHaveBeenCalledOnce();
+  });
+
+  it("should redact emails in arrays of objects", () => {
+    const item: TransportItem<LogEvent> = {
+      type: TransportItemType.LOG,
+      payload: {
+        message: "checking",
+        context: {
+          events: [
+            { message: "contact a@b.com" },
+            { message: "nothing here" },
+            { note: "try c@d.net" },
+          ],
+        },
+        timestamp: "123",
+        level: LogLevel.INFO,
+      },
+    };
+
+    const redacted = _beforeSend([redactors.email])(item)!;
+
+    expect(redacted.payload.context.events[0].message).toBe(
+      "contact [REDACTED EMAIL]",
+    );
+    expect(redacted.payload.context.events[2].note).toBe(
+      "try [REDACTED EMAIL]",
+    );
+    expect(faro.api.pushMeasurement).toHaveBeenCalledTimes(2);
+  });
+
+  it("should not break on nulls, undefined, numbers, booleans", () => {
+    const item: TransportItem<LogEvent> = {
+      type: TransportItemType.LOG,
+      payload: {
+        message: null as any,
+        count: 123,
+        active: true,
+        description: undefined,
+      } as any,
+      meta: null,
+    };
+
+    const redacted = _beforeSend([redactors.email])(item)!;
+
+    expect(redacted.payload.message).toBeNull();
+    expect(redacted.payload.count).toBe(123);
+    expect(redacted.payload.active).toBe(true);
+    expect("description" in redacted.payload).toBe(true); // still defined as undefined
+    expect(faro.api.pushMeasurement).not.toHaveBeenCalled();
+  });
+
+  it("should decode and redact encoded emails", () => {
+    const item: TransportItem<LogEvent> = {
+      type: TransportItemType.LOG,
+      payload: {
+        message: "contact%20user%40domain.com",
+        level: LogLevel.INFO,
+        context: {},
+        timestamp: "now",
+      },
+    };
+
+    const redacted = _beforeSend([redactors.email])(item)!;
+
+    expect(redacted.payload.message).toBe("contact [REDACTED EMAIL]");
+    expect(faro.api.pushMeasurement).toHaveBeenCalledOnce();
+  });
+});

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

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi, beforeEach, afterAll } from "vitest";
+
+import { emailRedactor } from "../../../../lib/internals/redaction/redactors/email";
+import { ipRedactor } from "../../../../lib/internals/redaction/redactors/ip";
+import { faro, TransportItemType } from "@grafana/faro-web-sdk";
+
+// Mock faro.api.pushMeasurement
+vi.mock("@grafana/faro-web-sdk", async () => {
+  const actual = await vi.importActual<any>("@grafana/faro-web-sdk");
+  return {
+    ...actual,
+    faro: {
+      api: {
+        pushMeasurement: vi.fn(),
+      },
+    },
+  };
+});
+
+describe("Email Redaction utils", () => {
+  afterAll(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("tracks metrics", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    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(faro.api.pushMeasurement).toHaveBeenCalledWith(
+        {
+          type: "faro_o11y_pii_redaction",
+          values: { redacted: 1 },
+        },
+        {
+          context: {
+            pii_type: "email",
+            redaction_source: TransportItemType.LOG,
+            pii_email_domain: "example.com",
+            pii_format: "string",
+          },
+        },
+      );
+    });
+
+    it("handles strings without PII unchanged", () => {
+      const input = "hello world";
+      const output = ipRedactor(input, "log", "string");
+
+      expect(output).toBe("hello world");
+      expect(faro.api.pushMeasurement).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Redacts email addresses", () => {
+    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/lib/internals/redactors/ip.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi, afterAll } from "vitest";
+
+import { faro } from "@grafana/faro-web-sdk";
+import { ipRedactor } from "../../../../lib/internals/redaction/redactors/ip";
+
+// Mock faro.api.pushMeasurement
+vi.mock("@grafana/faro-web-sdk", async () => {
+  const actual = await vi.importActual<any>("@grafana/faro-web-sdk");
+  return {
+    ...actual,
+    faro: {
+      api: {
+        pushMeasurement: vi.fn(),
+      },
+    },
+  };
+});
+
+describe("IP Redaction utils", () => {
+  afterAll(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("tracks metrics", () => {
+    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(faro.api.pushMeasurement).toHaveBeenCalledWith(
+        {
+          type: "faro_o11y_pii_redaction",
+          values: {
+            redacted: 1,
+          },
+        },
+        {
+          context: {
+            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(faro.api.pushMeasurement).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Redacts IPv4 and IPv6", () => {
+    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);
+      },
+    );
+  });
+});