@ogcio/o11y-sdk-node 0.1.0-beta.9 → 0.3.0

package/lib/traces.ts

@@ -1,5 +1,78 @@
-import { trace } from "@opentelemetry/api";
+import { Span, SpanOptions, SpanStatusCode, trace } from "@opentelemetry/api";
+import { getNodeSdkConfig } from "./config-manager.js";
 
+export type WithSpanParams<T> = {
+  /**
+   * The name of the trace the span should belong to.
+   * NOTE: If you want the new span to belong to an already existing trace, you should provide the same tracer name
+   */
+  traceName?: string;
+  spanName: string;
+  spanOptions?: SpanOptions;
+  /** A function defining the task you want to be wrapped by this span */
+  fn: (span: Span) => T | Promise<T>;
+};
+
+/**
+ * Generates a function wrapping a given Callable `fn` into an error handling block.
+ * Setting Span status and recording any caught exception before bubbling it up.
+ *
+ * Marks the span as ended once the provided callable has ended or an error has been caught.
+ *
+ * @returns {Promise<T>} where T is the type returned by the Callable.
+ * @throws any error thrown by the original Callable `fn` provided.
+ */
+function selfContainedSpanHandlerGenerator<T>(
+  fn: (span: Span) => T | Promise<T>,
+): (span: Span) => Promise<T> {
+  return async (span: Span) => {
+    try {
+      const fnResult = await fn(span);
+      span.setStatus({ code: SpanStatusCode.OK });
+      return fnResult;
+    } catch (err) {
+      if (err instanceof Error) {
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      }
+
+      span.recordException({ message: JSON.stringify(err) });
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: JSON.stringify(err),
+      });
+      throw err;
+    } finally {
+      span.end();
+    }
+  };
+}
+
+/**
+ * Gets the currently active OpenTelemetry span.
+ *
+ * @returns {Span | undefined} The active span with redaction logic applied,
+ * or `undefined` if there is no active span in context.
+ */
 export function getActiveSpan() {
   return trace.getActiveSpan();
 }
+
+export function withSpan<T>({
+  traceName,
+  spanName,
+  spanOptions = {},
+  fn,
+}: WithSpanParams<T>) {
+  const sdkConfig = getNodeSdkConfig();
+  const tracer = trace.getTracer(
+    traceName ?? sdkConfig.serviceName ?? "o11y-sdk",
+    sdkConfig.serviceVersion,
+  );
+  return tracer.startActiveSpan(
+    spanName,
+    spanOptions,
+    selfContainedSpanHandlerGenerator<T>(fn),
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogcio/o11y-sdk-node",
-  "version": "0.1.0-beta.9",
+  "version": "0.3.0",
   "description": "Opentelemetry standard instrumentation SDK for NodeJS based project",
   "main": "dist/index.js",
   "type": "module",
@@ -19,29 +19,31 @@
   "author": "team:ogcio/observability",
   "license": "ISC",
   "dependencies": {
+    "@grpc/grpc-js": "^1.13.4",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.57.0",
-    "@opentelemetry/core": "^2.0.0",
-    "@opentelemetry/exporter-logs-otlp-grpc": "^0.200.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.200.0",
-    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.200.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.200.0",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.200.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.200.0",
-    "@opentelemetry/instrumentation": "^0.200.0",
-    "@opentelemetry/otlp-exporter-base": "^0.200.0",
-    "@opentelemetry/resources": "^2.0.0",
-    "@opentelemetry/sdk-logs": "^0.200.0",
-    "@opentelemetry/sdk-metrics": "^2.0.0",
-    "@opentelemetry/sdk-node": "^0.200.0",
-    "@opentelemetry/sdk-trace-base": "^2.0.0"
+    "@opentelemetry/api-logs": "^0.203.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.60.1",
+    "@opentelemetry/core": "^2.0.1",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.202.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.202.0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.202.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.202.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.202.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.202.0",
+    "@opentelemetry/instrumentation": "^0.202.0",
+    "@opentelemetry/otlp-exporter-base": "^0.202.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-logs": "^0.202.0",
+    "@opentelemetry/sdk-metrics": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.202.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.1"
   },
   "devDependencies": {
-    "@types/node": "^22.13.9",
-    "@vitest/coverage-v8": "^3.0.8",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.2",
-    "vitest": "^3.0.8"
+    "@types/node": "^24.0.10",
+    "@vitest/coverage-v8": "^3.2.4",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
   },
   "engines": {
     "node": ">=20.6.0"

package/test/config-manager.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { getNodeSdkConfig, setNodeSdkConfig } from "../lib/config-manager";
+import { NodeSDKConfig } from "../lib";
+
+describe("Config Manager", () => {
+  it("throws if getConfig is called before initialization", () => {
+    expect(() => getNodeSdkConfig()).toThrow();
+  });
+
+  it("sdk defined config is not pollutable", () => {
+    const config: NodeSDKConfig = {
+      collectorUrl: "http://example.com",
+      serviceName: "MyService",
+      spanAttributes: {
+        "my.attribute": "value",
+      },
+    };
+
+    setNodeSdkConfig(config);
+
+    const cfg = getNodeSdkConfig();
+
+    // Top level
+    cfg.collectorUrl = "http://example.com/changed";
+    // Subfield
+    cfg.spanAttributes["my.attribute"] = "another-attribute";
+
+    // Ensure config values remain unchanged
+    expect(getNodeSdkConfig().collectorUrl).toStrictEqual(config.collectorUrl);
+    expect(getNodeSdkConfig().spanAttributes["my.attribute"]).toStrictEqual(
+      config.spanAttributes["my.attribute"],
+    );
+  });
+});

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

@@ -0,0 +1,139 @@
+import type { ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import type { 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})]`),
+  };
+});
+
+describe("PIIExporterDecorator", () => {
+  let decorator: PIIExporterDecorator;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  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("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("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();
+  });
+});

package/test/index.test.ts

@@ -1,13 +1,27 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
 import { NodeSDKConfig } from "../index";
 import { instrumentNode } from "../index";
-
-vi.mock("../lib/instrumentation.node", () => ({
-  default: vi.fn(),
-}));
+import * as buildNodeInstrumentationModule from "../lib/instrumentation.node";
+import { metrics } from "@opentelemetry/sdk-node";
 
 describe("instrumentNode", () => {
+  beforeEach(() => {
+    // @ts-ignore Avoid actually running exporters at any time in tests (overriding private method)
+    vi.spyOn(
+      metrics.PeriodicExportingMetricReader.prototype,
+      "_doRun",
+    ).mockImplementation(vi.fn());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   test("should call buildNodeInstrumentation with the provided config", async () => {
+    const instrumentationMock = vi
+      .spyOn(buildNodeInstrumentationModule, "default")
+      .mockImplementation(vi.fn());
+
     const config: NodeSDKConfig = {
       serviceName: "custom-service",
       collectorUrl: "http://custom-collector.com",
@@ -23,16 +37,34 @@ describe("instrumentNode", () => {
       },
     };
 
-    const buildNodeInstrumentation = await import(
-      "../lib/instrumentation.node"
-    );
+    await instrumentNode(config);
 
-    instrumentNode(config);
+    expect(instrumentationMock).toHaveBeenCalledWith(config);
+  });
 
-    expect(buildNodeInstrumentation.default).toHaveBeenCalledWith(config);
+  test("should not throw when called without arguments", async () => {
+    await expect(instrumentNode()).resolves.not.toThrow();
   });
 
-  test("should not throw when called without arguments", () => {
-    expect(() => instrumentNode()).not.toThrow();
+  test("should invoke instrumentation shutdown on SIGTERM", async () => {
+    const config: NodeSDKConfig = {
+      serviceName: "custom-service",
+      collectorUrl: "http://custom-collector.com",
+      protocol: "grpc",
+      resourceAttributes: {
+        "team.infra.cluster": "dev-01",
+        "team.infra.pod": "01",
+        "team.service.type": "fastify",
+      },
+      spanAttributes: {
+        "signal.namespace": "example",
+        "signal.number": () => "callback",
+      },
+    };
+
+    const sdk = await instrumentNode(config);
+    const shutdownMock = vi.spyOn(sdk, "shutdown");
+    process.emit("SIGTERM");
+    expect(shutdownMock).toHaveBeenCalled();
   });
 });

package/test/integration/README.md

@@ -22,5 +22,5 @@ The `run.sh` script performs the following steps:
 - run fastify app in a docker container
 - ensure is running otherwise exit process
 - execute some curl to the fastify microservice
-- persit alloy log to a file and save to following path `/packages/sdk-node/test/integration/`
+- persist alloy log to a file and save to following path `/packages/sdk-node/test/integration/`
 - docker turn down process (containers/network/image)

package/test/integration/{integration.test.ts → http-tracing.integration.test.ts}

@@ -10,8 +10,6 @@ describe("instrumentation integration test", () => {
     let health_traces_counter = 0;
     let dummy_traces_counter = 0;
 
-    console.log(data.split(/\nts=/).length);
-
     for (const line of data.split(/\nts=/)) {
       const parsedLine: Record<string, object | string | number> =
         parseLog(line);

package/test/integration/pii.integration.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, assert } from "vitest";
+import { parseLog } from "../utils/alloy-log-parser";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+describe("pii integration test", () => {
+  test("should check redacted attributes and detect zero emails in logs", async () => {
+    const data = await readFile(join(__dirname, "logs.txt"), "utf-8");
+
+    let health_traces_counter = 0;
+    let dummy_traces_counter = 0;
+    let email_not_redacted = 0;
+
+    for (const line of data.split(/\nts=/)) {
+      const parsedLine: Record<string, object | string | number> =
+        parseLog(line);
+
+      if (
+        parsedLine["attributes"] &&
+        parsedLine["attributes"]["span_kind"] &&
+        parsedLine["attributes"]["span_kind"] === "log"
+      ) {
+        const matches = (parsedLine["log_body"] as string).match(
+          /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        );
+        if (matches) {
+          email_not_redacted++;
+        }
+      }
+
+      if (
+        parsedLine["attributes"] &&
+        parsedLine["attributes"]["span_kind"] &&
+        parsedLine["attributes"]["span_kind"] === "trace"
+      ) {
+        if (parsedLine["attributes"]["http.target"] === "/api/dummy") {
+          dummy_traces_counter++;
+
+          // verify global sdk span resource
+          assert.equal(
+            parsedLine["resource_attributes"]["email"],
+            "[REDACTED EMAIL]",
+          );
+
+          // verify global sdk span attributes
+          assert.equal(parsedLine["attributes"]["email"], "[REDACTED EMAIL]");
+          // verify custom runtime span attributes
+          assert.equal(
+            parsedLine["attributes"]["multiple.email"],
+            "[REDACTED EMAIL]",
+          );
+
+          // verify global sdk span attributes
+          assert.equal(parsedLine["events"]["email"], "[REDACTED EMAIL]");
+
+          continue;
+        }
+        if (parsedLine["attributes"]["http.target"] === "/api/health") {
+          health_traces_counter++;
+        }
+      }
+    }
+
+    assert.equal(email_not_redacted, 0);
+    assert.equal(health_traces_counter, 0);
+    assert.equal(dummy_traces_counter, 2);
+  });
+});

package/test/integration/run.sh

@@ -16,7 +16,7 @@ docker run -d \
     --name $ALLOY_CONTAINER_NAME \
     -p 4317:4317 \
     -p 4318:4318 \
-    grafana/alloy \
+    grafana/alloy:v1.9.2 \
     run --server.http.listen-addr=0.0.0.0:12345 --stability.level=experimental /etc/alloy/config.alloy
 
 MAX_RETRIES=10
@@ -69,7 +69,7 @@ if [[ $ERROR_CODE -eq 0 ]]; then
 fi
 
 # sleep N seconds to await instrumentation flow send and receiving signals
-sleep 10
+sleep 1
 
 # Copy logs from container to file
 docker container logs $ALLOY_CONTAINER_NAME >&$ROOT_PATH/packages/sdk-node/test/integration/logs.txt

package/test/internals/hooks.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from "vitest";
+import { _shutdownHook } from "../../lib/internals/hooks";
+
+describe("shutdown hook", () => {
+  it("should call sdk.shutdown and log success on SIGTERM", async () => {
+    const shutdownMock = vi.fn().mockResolvedValue(undefined);
+    const consoleLogMock = vi
+      .spyOn(console, "log")
+      .mockImplementation(() => {});
+
+    _shutdownHook({ shutdown: shutdownMock });
+
+    process.emit("SIGTERM");
+    // Wait for async logic
+    await Promise.resolve();
+
+    expect(shutdownMock).toHaveBeenCalled();
+    expect(consoleLogMock).toHaveBeenCalledWith(
+      "NodeJS OpenTelemetry instrumentation shutdown successfully",
+    );
+
+    consoleLogMock.mockRestore();
+  });
+
+  it("should catch and log errors on shutdown failure", async () => {
+    const error = new Error("Shutdown failed");
+    const shutdownMock = vi.fn().mockRejectedValue(error);
+    const consoleErrorMock = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    _shutdownHook({ shutdown: shutdownMock });
+
+    process.emit("SIGTERM");
+    // Wait for async logic
+    await Promise.resolve();
+
+    expect(consoleErrorMock).toHaveBeenCalledWith(
+      "Error shutting down NodeJS OpenTelemetry instrumentation:",
+      error,
+    );
+
+    consoleErrorMock.mockRestore();
+  });
+});

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

@@ -0,0 +1,141 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  _cleanStringPII,
+  _cleanLogBodyPII,
+} from "../../lib/internals/pii-detection.js";
+import * as sharedMetrics from "../../lib/internals/shared-metrics.js";
+
+describe("PII Detection Utils", () => {
+  const mockMetricAdd = vi.fn();
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.spyOn(sharedMetrics, "_getPIICounterRedactionMetric").mockReturnValue({
+      add: mockMetricAdd,
+    });
+  });
+
+  describe("_cleanStringPII", () => {
+    it("redacts plain email", () => {
+      const input = "admin@example.com";
+      const output = _cleanStringPII(input, "log");
+
+      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");
+
+      expect(output).toBe("[REDACTED EMAIL]");
+      expect(mockMetricAdd).toHaveBeenCalledWith(
+        1,
+        expect.objectContaining({
+          pii_format: "url",
+          pii_email_domain: "gmail.com",
+        }),
+      );
+    });
+
+    it("handles strings without email unchanged", () => {
+      const input = "hello world";
+      const output = _cleanStringPII(input, "log");
+
+      expect(output).toBe("hello world");
+      expect(mockMetricAdd).not.toHaveBeenCalled();
+    });
+
+    it("handles array of strings", () => {
+      const input = ["one@gmail.com", "two@example.com"];
+      const output = _cleanStringPII(input, "log");
+
+      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(mockMetricAdd).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("_cleanLogBodyPII", () => {
+    it("cleans string email", () => {
+      const result = _cleanLogBodyPII("demo@abc.com");
+      expect(result).toBe("[REDACTED EMAIL]");
+    });
+
+    it("cleans deeply nested object", () => {
+      const input = {
+        user: {
+          email: "test@gmail.com",
+          profile: {
+            contact: "foo@example.com",
+          },
+        },
+        status: "active",
+      };
+
+      const result = _cleanLogBodyPII(input);
+
+      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 = _cleanLogBodyPII(buffer);
+      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 = _cleanLogBodyPII(corrupted);
+
+      // 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 = _cleanLogBodyPII([
+        "bob@abc.com",
+        123,
+        { nested: "jane@example.com" },
+      ]);
+
+      expect(result).toEqual([
+        "[REDACTED EMAIL]",
+        123,
+        { nested: "[REDACTED EMAIL]" },
+      ]);
+    });
+
+    it("passes null and boolean through", () => {
+      expect(_cleanLogBodyPII(null)).toBeNull();
+      expect(_cleanLogBodyPII(undefined)).toBeUndefined();
+      expect(_cleanLogBodyPII(true)).toBe(true);
+      expect(_cleanLogBodyPII(false)).toBe(false);
+    });
+  });
+});