@ogcio/o11y-sdk-node 0.4.0 → 0.4.2

package/test/integration/docker-utils.sh

@@ -0,0 +1,214 @@
+#!/bin/bash
+
+: '
+Build a new docker image of a given Dockerfile, if already exists skip build.
+
+@param container_name docker container name
+
+@return int error code
+0. success
+1. validation error
+'
+build_image() {
+    if [ "$#" -lt 3 ] || [ "$#" -gt 4 ]; then
+        echo "Error: build_image expected 3 or 4 parameters, got $#." >&2
+        echo "Usage: build_image <image_name> <dockerfile_path> <context_path> [max_age_minutes]" >&2
+        return 1
+    fi
+    
+    
+    local image_name="$1"
+    local dockerfile_path="$2"
+    local context_path="$3"
+    local max_age_minutes="${4:-30}"  # default threshold = 30 minutes
+    
+    if docker image inspect "$image_name" > /dev/null 2>&1; then
+        echo "Image $image_name already exists. Checking age..."
+        
+        # Extract the Created timestamp from docker inspect (ISO 8601 format)
+        local created_at
+        created_at=$(docker image inspect --format '{{.Created}}' "$image_name")
+        if [ -z "$created_at" ]; then
+            echo "Warning: Could not determine creation date. Proceeding without rebuild check." >&2
+            return 0
+        fi
+        
+        # Convert created_at to epoch seconds
+        local created_epoch
+        created_epoch=$(date -d "$created_at" +%s 2>/dev/null)
+        
+        # Current time in epoch seconds
+        local now_epoch
+        now_epoch=$(date +%s)
+        
+        # Calculate age in minutes
+        local age_minutes=$(( (now_epoch - created_epoch) / 60 ))
+        
+        echo "Image $image_name is $age_minutes minutes old (threshold: $max_age_minutes minutes)."
+        
+        if [ "$age_minutes" -ge "$max_age_minutes" ]; then
+            echo "Image is too old. Rebuilding..."
+            docker build -t $image_name -f $dockerfile_path $context_path
+            return $?
+        else
+            echo "Image is recent. Skipping rebuild."
+            return 0
+        fi
+    else
+        echo "Image $image_name not found. Building..."
+        docker build -t "$image_name" -f "$dockerfile_path" "$context_path"
+        return $?
+    fi
+}
+
+: '
+Stop and remove a docker container for the given input container name.
+
+@param container_name docker container name
+
+@return int error code
+0. success
+1. validation error
+'
+container_stop_and_rm() {
+    local container_name="$1"
+    
+    if [[ -z "$container_name" ]]; then
+        echo "Error: container_name must have a value."
+        return 1
+    fi
+    
+    docker container stop $container_name
+    docker container rm -f $container_name
+    
+    return $?
+}
+
+: '
+Run a new alloy container and check if the status is running.
+
+@param root_path volume root path for alloy file config
+@param network_name docker network name
+@param container_name docker container name
+
+@optional max_retries
+@default 10
+
+@return int error code
+0. success
+1. validation error
+2. execution failed
+'
+run_and_check_alloy() {
+    
+    if [ "$#" -lt 3 ]; then
+        echo "Error: run_and_check_alloy expected 3 parameters, got $#." >&2
+        return 1
+    fi
+    
+    local root_path="$1"
+    local network_name="$2"
+    local container_name="$3"
+    local max_retries="${4:-10}"
+    local counter_retries=0
+    
+    if [[ -z "$root_path" || -z "$network_name" || -z "$container_name" ]]; then
+        echo "Error: root_path, network_name, and container_name must all have values."
+        return 1
+    fi
+    
+    if ! [[ "$max_retries" =~ ^[0-9]+$ ]]; then
+        echo "Error: max_retries parameter must be a number." >&2
+        return 1
+    fi
+    
+    docker run -d \
+    -v "$root_path/alloy/integration-test.alloy:/etc/alloy/config.alloy:ro" \
+    --network $network_name \
+    --name $container_name \
+    -p 4317:4317 \
+    -p 4318:4318 \
+    grafana/alloy:v1.9.2 \
+    run --server.http.listen-addr=0.0.0.0:12345 --stability.level=experimental /etc/alloy/config.alloy
+    
+    echo "$container_name container status"
+    until [ "$(docker inspect -f {{.State.Running}} $container_name)" = true ]; do
+        sleep 2
+        docker inspect -f {{.State.Running}} $container_name
+        counter_retries=$((counter_retries + 1))
+        if [ $counter_retries -ge $max_retries ]; then
+            echo "Exceeded maximum retries. Exiting."
+            return 2
+        fi
+    done
+    
+    return 0
+}
+
+: '
+Run a new fastify microservice container and check if the status is running.
+
+@param network_name docker network name
+@param collector_url otel collector grpc endpoint
+@param container_name docker container name
+@param build_id current pipeline build id
+
+@optional max_retries
+@default 10
+
+@return int error code
+0. success
+1. validation error
+2. execution failed
+'
+run_and_check_fastify() {
+    
+    if [ "$#" -lt 4 ]; then
+        echo "Error: run_and_check_alloy expected 3 parameters, got $#." >&2
+        return 1
+    fi
+    
+    local network_name="$1"
+    local collector_url="$2"
+    local container_name="$3"
+    local build_id="$4"
+    local max_retries="${5:-10}"
+    local counter_retries=0
+    
+    if [[ -z "$build_id" || -z "$network_name" || -z "$container_name" ]]; then
+        echo "Error: build_id, network_name, and container_name must all have values."
+        return 1
+    fi
+    
+    if ! [[ "$max_retries" =~ ^[0-9]+$ ]]; then
+        echo "Error: max_retries parameter must be a number." >&2
+        return 1
+    fi
+    
+    docker run --detach \
+    --network $network_name \
+    --name $container_name \
+    -e DB_DISABLED="true" \
+    -e SERVER_HOST="0.0.0.0" \
+    -e OTEL_COLLECTOR_URL=$collector_url \
+    --health-cmd="curl -f http://${container_name}:9091/api/health > /dev/null || exit 1" \
+    --health-start-period=1s \
+    --health-retries=10 \
+    --health-interval=1s \
+    -p 9091:9091 \
+    $container_name:$build_id
+    
+    counter_retries=0
+    echo "$container_name container status"
+    until [ "$(docker inspect -f {{.State.Health.Status}} $container_name)" = "healthy" ]; do
+        sleep 1
+        docker inspect -f {{.State.Health.Status}} $container_name
+        counter_retries=$((counter_retries + 1))
+        if [ $counter_retries -ge $max_retries ]; then
+            echo "Exceeded maximum retries. Exiting."
+            return 2
+        fi
+    done
+    
+    return 0
+}

package/test/integration/main.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+set -e
+set -o pipefail
+
+if [ $# -lt 2 ]; then
+    echo "Usage: $0 <build-id> <root-path>"
+    exit 1
+fi
+
+BUILD_ID=$1
+ROOT_PATH=$2
+
+NETWORK_NAME="${BUILD_ID}_testnetwork"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+docker network create $NETWORK_NAME
+
+TEST_SCRIPTS=( $(find . -type f -path "./packages/sdk-node/test/integration/test*/run.sh" | sort) )
+
+FAILURES=0
+
+for test_script in "${TEST_SCRIPTS[@]}"; do
+    TEST_DIR=$(dirname "$test_script")
+    TEST_NAME=$(basename "$TEST_DIR")
+    
+    echo "Running test: $TEST_NAME ($test_script)"
+    
+    # Run the test
+    bash "$test_script" "$BUILD_ID" "$ROOT_PATH" "$NETWORK_NAME"
+    EXIT_CODE=$?
+    
+    if [ $EXIT_CODE -eq 0 ]; then
+        echo "$test_script completed"
+    else
+        echo "❌ $test_script failed with exit code $EXIT_CODE"
+        FAILURES=$((FAILURES + 1))
+    fi
+    echo "------------------------------"
+done
+
+# Remove network and images from docker host
+bash "$SCRIPT_DIR/teardown.sh" "$BUILD_ID" "$NETWORK_NAME"
+
+# Final summary
+if [ $FAILURES -eq 0 ]; then
+    echo "All tests ready!"
+    exit 0
+else
+    echo "$FAILURES test(s) failed."
+    exit 1
+fi

package/test/integration/teardown.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+BUILD_ID=$1
+NETWORK_NAME=$2
+
+docker network rm $NETWORK_NAME
+docker rmi -f $(docker images --filter "reference=*:$BUILD_ID" -q)

package/test/integration/{http-tracing.integration.test.ts → test_fastify-o11y-pii-enabled/http-tracing.integration.test.ts}

@@ -1,5 +1,5 @@
 import { describe, test, assert } from "vitest";
-import { parseLog } from "../utils/alloy-log-parser";
+import { parseLog } from "../../utils/alloy-log-parser";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 

package/test/integration/{pii.integration.test.ts → test_fastify-o11y-pii-enabled/pii.integration.test.ts}

@@ -1,5 +1,5 @@
 import { describe, test, assert } from "vitest";
-import { parseLog } from "../utils/alloy-log-parser";
+import { parseLog } from "../../utils/alloy-log-parser";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 

package/test/integration/test_fastify-o11y-pii-enabled/run.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# @docs: packages/sdk-node/test/integration/README.md#test_fastify-o11y-pii-enabled
+BUILD_ID=$1
+ROOT_PATH=$2
+NETWORK_NAME=$3
+
+ALLOY_CONTAINER_NAME="integrationalloy"
+NODE_CONTAINER_NAME="${BUILD_ID}_fastify_app"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOG_FILE="$SCRIPT_DIR/logs.txt"
+ERROR_CODE=0
+
+source "$SCRIPT_DIR/../docker-utils.sh"
+
+build_image "${NODE_CONTAINER_NAME}:${BUILD_ID}" "$ROOT_PATH/examples/fastify/Dockerfile" "$ROOT_PATH/"
+
+run_and_check_alloy $ROOT_PATH $NETWORK_NAME $ALLOY_CONTAINER_NAME
+ERROR_CODE=$?
+
+if [[ $ERROR_CODE -eq 0 ]]; then
+    run_and_check_fastify $NETWORK_NAME "http://integrationalloy:4317" $NODE_CONTAINER_NAME $BUILD_ID
+    ERROR_CODE=$?
+fi
+
+if [[ $ERROR_CODE -eq 0 ]]; then
+    sleep 2
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
+    sleep 2
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
+fi
+
+# sleep N seconds to await instrumentation flow send and receiving signals
+sleep 1
+
+# Copy logs from container to file
+docker container logs $ALLOY_CONTAINER_NAME >&$LOG_FILE
+echo "log file at $LOG_FILE"
+
+container_stop_and_rm $ALLOY_CONTAINER_NAME
+container_stop_and_rm $NODE_CONTAINER_NAME
+
+exit $ERROR_CODE

package/test/integration/test_without-o11y/run.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# @docs: packages/sdk-node/test/integration/README.md#test_without-o11y
+BUILD_ID=$1
+ROOT_PATH=$2
+NETWORK_NAME=$3
+
+NODE_CONTAINER_NAME="${BUILD_ID}_fastify_app"
+ERROR_CODE=0
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOG_FILE="$SCRIPT_DIR/logs.txt"
+
+source "$SCRIPT_DIR/../docker-utils.sh"
+
+build_image "${NODE_CONTAINER_NAME}:${BUILD_ID}" "$ROOT_PATH/examples/fastify/Dockerfile" "$ROOT_PATH/"
+
+run_and_check_fastify $NETWORK_NAME "" $NODE_CONTAINER_NAME $BUILD_ID
+ERROR_CODE=$?
+
+if [[ $ERROR_CODE -eq 0 ]]; then
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
+    sleep 1
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
+fi
+
+docker container logs $NODE_CONTAINER_NAME >&$LOG_FILE
+echo "log file at $LOG_FILE"
+
+container_stop_and_rm $NODE_CONTAINER_NAME
+
+exit $ERROR_CODE

package/test/integration/test_without-o11y/verify-status.integration.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+describe("Log validation for /api/dummy with instrumentation disabled", async () => {
+  const log = await readFile(join(__dirname, "logs.txt"), "utf-8");
+
+  it("should contain message that collector URL is not set", () => {
+    expect(log).toContain(
+      "collectorUrl not set. Skipping NodeJS OpenTelemetry instrumentation.",
+    );
+  });
+
+  it("should have all /api/dummy responses with status code 200", () => {
+    // Extract all request IDs for /api/dummy requests
+    const dummyRequestIds = [
+      ...log.matchAll(/"reqId":"(.*?)","req":\{[^}]*"url":"\/api\/dummy"/g),
+    ].map((match) => match[1]);
+
+    expect(dummyRequestIds.length).toBeGreaterThan(0);
+
+    // For each /api/dummy request ID, verify that its response status is 200
+    const non200Responses = dummyRequestIds.filter((reqId) => {
+      const responseMatch = log.match(
+        new RegExp(`"reqId":"${reqId}".*"statusCode":(\\d+)`),
+      );
+      return responseMatch && Number(responseMatch[1]) !== 200;
+    });
+
+    expect(non200Responses).toEqual([]); // No non-200 responses allowed
+  });
+});

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

@@ -1,10 +1,12 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
 import {
   _cleanStringPII,
-  _cleanLogBodyPII,
+  _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();
@@ -32,7 +34,7 @@ describe("PII Detection Utils", () => {
       );
     });
 
-    it("redacts PII in URL-encoded string", () => {
+    it("redacts email in URL-encoded string", () => {
       const input = "user%40gmail.com";
       const output = _cleanStringPII(input, "log", [emailRedactor]);
 
@@ -46,6 +48,21 @@ describe("PII Detection Utils", () => {
       );
     });
 
+    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]);
@@ -54,16 +71,10 @@ describe("PII Detection Utils", () => {
       expect(mockMetricAdd).not.toHaveBeenCalled();
     });
 
-    it("handles array of strings", () => {
-      const input = ["one@gmail.com", "two@example.com"];
-      const output = _cleanStringPII(input, "log", [emailRedactor]);
-
-      expect(output).toEqual(["[REDACTED EMAIL]", "[REDACTED EMAIL]"]);
-      expect(mockMetricAdd).toHaveBeenCalledTimes(2);
-    });
-
     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]),
@@ -72,12 +83,22 @@ describe("PII Detection Utils", () => {
     });
   });
 
-  describe("_cleanLogBodyPII", () => {
+  describe("_recursiveObjectClean", () => {
     it("cleans string PII", () => {
-      const result = _cleanLogBodyPII("demo@abc.com", [emailRedactor]);
+      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: {
@@ -89,7 +110,7 @@ describe("PII Detection Utils", () => {
         status: "active",
       };
 
-      const result = _cleanLogBodyPII(input, [emailRedactor]);
+      const result = _recursiveObjectClean(input, "log", [emailRedactor]);
 
       expect(result).toEqual({
         user: {
@@ -105,7 +126,7 @@ describe("PII Detection Utils", () => {
     it("cleans Uint8Array input", () => {
       const str = "admin@gmail.com";
       const buffer = new TextEncoder().encode(str);
-      const result = _cleanLogBodyPII(buffer, [emailRedactor]);
+      const result = _recursiveObjectClean(buffer, "log", [emailRedactor]);
       const decoded = new TextDecoder().decode(result as Uint8Array);
 
       expect(decoded).toBe("[REDACTED EMAIL]");
@@ -113,7 +134,7 @@ describe("PII Detection Utils", () => {
 
     it("skips malformed Uint8Array decode", () => {
       const corrupted = new Uint8Array([0xff, 0xfe, 0xfd]);
-      const result = _cleanLogBodyPII(corrupted, [emailRedactor]);
+      const result = _recursiveObjectClean(corrupted, "log", [emailRedactor]);
 
       // Should return a Uint8Array, but unmodified/redaction should not happen
       expect(result).toBeInstanceOf(Uint8Array);
@@ -121,8 +142,9 @@ describe("PII Detection Utils", () => {
     });
 
     it("cleans arrays of values", () => {
-      const result = _cleanLogBodyPII(
+      const result = _recursiveObjectClean(
         ["bob@abc.com", 123, { nested: "jane@example.com" }],
+        "log",
         [emailRedactor],
       );
 
@@ -134,10 +156,110 @@ describe("PII Detection Utils", () => {
     });
 
     it("passes null and boolean through", () => {
-      expect(_cleanLogBodyPII(null, [emailRedactor])).toBeNull();
-      expect(_cleanLogBodyPII(undefined, [emailRedactor])).toBeUndefined();
-      expect(_cleanLogBodyPII(true, [emailRedactor])).toBe(true);
-      expect(_cleanLogBodyPII(false, [emailRedactor])).toBe(false);
+      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/ip.test.ts

@@ -67,9 +67,13 @@ describe("IP Redaction utils", () => {
       ${"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]"}

package/test/traces/active-span.test.ts

@@ -1,8 +1,6 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import * as piiDetection from "../../lib/internals/redaction/pii-detection.js";
-import { getActiveSpan } from "../../lib/traces.js";
-import { MockSpan } from "../utils/mock-signals.js";
+import { describe, expect, it, vi } from "vitest";
 import { setNodeSdkConfig } from "../../lib/config-manager.js";
+import { getActiveSpan } from "../../lib/traces.js";
 
 describe("getActiveSpan", () => {
   it("returns undefined if no active span", async () => {