@foam-ai/node 0.1.0-alpha.5 → 0.1.0-alpha.6

package/dist/exporters.js

@@ -1,81 +1,158 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FoamMetricExporter = exports.FoamLogExporter = exports.FoamTraceExporter = void 0;
+const core_1 = require("@opentelemetry/core");
 const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
 const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
 const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
 const resources_1 = require("@opentelemetry/resources");
+const before_send_js_1 = require("./before-send.js");
 const constants_js_1 = require("./constants.js");
 const endpoint_js_1 = require("./endpoint.js");
+const redaction_js_1 = require("./redaction.js");
+function redactionConfig(options) {
+    return options.redaction ?? (0, redaction_js_1.getActiveRedactionConfig)();
+}
+function copySpan(span, name, attributes, events, links, overlay) {
+    return {
+        name,
+        kind: span.kind,
+        spanContext: span.spanContext.bind(span),
+        parentSpanContext: span.parentSpanContext,
+        startTime: span.startTime,
+        endTime: span.endTime,
+        status: span.status,
+        attributes,
+        links,
+        events,
+        duration: span.duration,
+        ended: span.ended,
+        resource: overlay ? span.resource.merge(overlay) : span.resource,
+        instrumentationScope: span.instrumentationScope,
+        droppedAttributesCount: span.droppedAttributesCount,
+        droppedEventsCount: span.droppedEventsCount,
+        droppedLinksCount: span.droppedLinksCount,
+    };
+}
 class FoamTraceExporter extends exporter_trace_otlp_http_1.OTLPTraceExporter {
     stamp;
-    constructor(token, stamp) {
+    options;
+    constructor(token, stamp, options = {}) {
         super({
             url: `${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_TRACES_PATH}`,
             headers: { Authorization: `Bearer ${token}` },
         });
         this.stamp = stamp;
+        this.options = options;
     }
     export(spans, callback) {
-        const { stamp } = this;
-        if (!stamp) {
-            super.export(spans, callback);
+        const config = redactionConfig(this.options);
+        const overlay = this.stamp ? (0, resources_1.resourceFromAttributes)(this.stamp) : undefined;
+        const output = [];
+        for (const span of spans) {
+            let name = span.name;
+            let sourceAttributes = span.attributes;
+            if (this.options.beforeSend) {
+                const result = (0, before_send_js_1.invokeBeforeSend)(this.options.beforeSend, {
+                    type: "span",
+                    name,
+                    attributes: sourceAttributes,
+                });
+                if (result === null)
+                    continue;
+                if (result?.type === "span") {
+                    name = result.name;
+                    sourceAttributes = result.attributes;
+                }
+            }
+            const attributes = (0, redaction_js_1.redactAttributesCopy)(sourceAttributes, config);
+            const events = (span.events ?? []).map((event) => event.attributes
+                ? {
+                    ...event,
+                    attributes: (0, redaction_js_1.redactAttributesCopy)(event.attributes, config),
+                }
+                : event);
+            const links = (span.links ?? []).map((link) => link.attributes
+                ? {
+                    ...link,
+                    attributes: (0, redaction_js_1.redactAttributesCopy)(link.attributes, config),
+                }
+                : link);
+            output.push(copySpan(span, name, attributes, events, links, overlay));
+        }
+        if (output.length === 0) {
+            callback({ code: core_1.ExportResultCode.SUCCESS });
             return;
         }
-        const overlay = (0, resources_1.resourceFromAttributes)(stamp);
-        const copies = spans.map((span) => ({
-            name: span.name,
-            kind: span.kind,
-            spanContext: span.spanContext.bind(span),
-            parentSpanContext: span.parentSpanContext,
-            startTime: span.startTime,
-            endTime: span.endTime,
-            status: span.status,
-            attributes: span.attributes,
-            links: span.links,
-            events: span.events,
-            duration: span.duration,
-            ended: span.ended,
-            resource: span.resource.merge(overlay),
-            instrumentationScope: span.instrumentationScope,
-            droppedAttributesCount: span.droppedAttributesCount,
-            droppedEventsCount: span.droppedEventsCount,
-            droppedLinksCount: span.droppedLinksCount,
-        }));
-        super.export(copies, callback);
+        super.export(output, callback);
     }
 }
 exports.FoamTraceExporter = FoamTraceExporter;
+function copyLog(record, body, severityText, attributes, overlay) {
+    return {
+        hrTime: record.hrTime,
+        hrTimeObserved: record.hrTimeObserved,
+        spanContext: record.spanContext,
+        severityText,
+        severityNumber: record.severityNumber,
+        body,
+        eventName: record.eventName,
+        resource: overlay ? record.resource.merge(overlay) : record.resource,
+        instrumentationScope: record.instrumentationScope,
+        attributes,
+        droppedAttributesCount: record.droppedAttributesCount,
+    };
+}
+function redactBody(body, config) {
+    if (body === undefined)
+        return undefined;
+    if (typeof body === "string")
+        return (0, redaction_js_1.redactString)(body, config);
+    return (0, redaction_js_1.redactDeep)(body, config);
+}
 class FoamLogExporter extends exporter_logs_otlp_http_1.OTLPLogExporter {
     stamp;
-    constructor(token, stamp) {
+    options;
+    constructor(token, stamp, options = {}) {
         super({
             url: `${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_LOGS_PATH}`,
             headers: { Authorization: `Bearer ${token}` },
         });
         this.stamp = stamp;
+        this.options = options;
     }
     export(records, callback) {
-        const { stamp } = this;
-        if (!stamp) {
-            super.export(records, callback);
+        const config = redactionConfig(this.options);
+        const overlay = this.stamp ? (0, resources_1.resourceFromAttributes)(this.stamp) : undefined;
+        const output = [];
+        for (const record of records) {
+            let sourceBody = record.body;
+            let severityText = record.severityText;
+            let sourceAttributes = record.attributes;
+            if (this.options.beforeSend) {
+                const result = (0, before_send_js_1.invokeBeforeSend)(this.options.beforeSend, {
+                    type: "log",
+                    body: sourceBody,
+                    severityText,
+                    attributes: sourceAttributes,
+                });
+                if (result === null)
+                    continue;
+                if (result?.type === "log") {
+                    sourceBody = result.body;
+                    severityText = result.severityText;
+                    sourceAttributes = result.attributes;
+                }
+            }
+            const body = redactBody(sourceBody, config);
+            const attributes = (0, redaction_js_1.redactAttributesCopy)(sourceAttributes, config);
+            output.push(copyLog(record, body, severityText, attributes, overlay));
+        }
+        if (output.length === 0) {
+            callback({ code: core_1.ExportResultCode.SUCCESS });
             return;
         }
-        const overlay = (0, resources_1.resourceFromAttributes)(stamp);
-        const copies = records.map((record) => ({
-            hrTime: record.hrTime,
-            hrTimeObserved: record.hrTimeObserved,
-            spanContext: record.spanContext,
-            severityText: record.severityText,
-            severityNumber: record.severityNumber,
-            body: record.body,
-            eventName: record.eventName,
-            resource: record.resource.merge(overlay),
-            instrumentationScope: record.instrumentationScope,
-            attributes: record.attributes,
-            droppedAttributesCount: record.droppedAttributesCount,
-        }));
-        super.export(copies, callback);
+        super.export(output, callback);
     }
 }
 exports.FoamLogExporter = FoamLogExporter;
@@ -89,14 +166,13 @@ class FoamMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporter
         this.stamp = stamp;
     }
     export(resourceMetrics, callback) {
-        const { stamp } = this;
-        if (!stamp) {
+        if (!this.stamp) {
             super.export(resourceMetrics, callback);
             return;
         }
         super.export({
             ...resourceMetrics,
-            resource: resourceMetrics.resource.merge((0, resources_1.resourceFromAttributes)(stamp)),
+            resource: resourceMetrics.resource.merge((0, resources_1.resourceFromAttributes)(this.stamp)),
         }, callback);
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { init } from "./init.js";
+export { init, type InitOptions } from "./init.js";
+export type { BeforeSendEvent, BeforeSendHook, } from "./before-send.js";
+export type { RedactOptions } from "./redaction.js";
 export { getState } from "./state.js";
-export { createFoamIngestLogRecordProcessor, createFoamIngestMetricReader, createFoamIngestSpanProcessor, } from "./ingest.js";
+export { setEndpoint } from "./endpoint.js";
+export { createFoamIngestLogRecordProcessor, createFoamIngestMetricReader, createFoamIngestSpanProcessor, type FoamIngestOptions, } from "./ingest.js";
 export { extractTraceContext, getBaggage, injectTraceContext, setBaggage, } from "./propagation.js";
 export { addUpDownCounter, incrementCounter, recordHistogram, setMetric, } from "./metrics.js";
 export { log, SeverityNumber } from "./logs.js";

package/dist/index.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordException = exports.SeverityNumber = exports.log = exports.setMetric = exports.recordHistogram = exports.incrementCounter = exports.addUpDownCounter = exports.setBaggage = exports.injectTraceContext = exports.getBaggage = exports.extractTraceContext = exports.createFoamIngestSpanProcessor = exports.createFoamIngestMetricReader = exports.createFoamIngestLogRecordProcessor = exports.getState = exports.init = void 0;
+exports.recordException = exports.SeverityNumber = exports.log = exports.setMetric = exports.recordHistogram = exports.incrementCounter = exports.addUpDownCounter = exports.setBaggage = exports.injectTraceContext = exports.getBaggage = exports.extractTraceContext = exports.createFoamIngestSpanProcessor = exports.createFoamIngestMetricReader = exports.createFoamIngestLogRecordProcessor = exports.setEndpoint = exports.getState = exports.init = void 0;
 var init_js_1 = require("./init.js");
 Object.defineProperty(exports, "init", { enumerable: true, get: function () { return init_js_1.init; } });
 var state_js_1 = require("./state.js");
 Object.defineProperty(exports, "getState", { enumerable: true, get: function () { return state_js_1.getState; } });
+var endpoint_js_1 = require("./endpoint.js");
+Object.defineProperty(exports, "setEndpoint", { enumerable: true, get: function () { return endpoint_js_1.setEndpoint; } });
 var ingest_js_1 = require("./ingest.js");
 Object.defineProperty(exports, "createFoamIngestLogRecordProcessor", { enumerable: true, get: function () { return ingest_js_1.createFoamIngestLogRecordProcessor; } });
 Object.defineProperty(exports, "createFoamIngestMetricReader", { enumerable: true, get: function () { return ingest_js_1.createFoamIngestMetricReader; } });

package/dist/ingest.d.ts

@@ -1,6 +1,12 @@
 import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
-export declare function createFoamIngestSpanProcessor(name: string, environment: string, token: string): SpanProcessor;
-export declare function createFoamIngestLogRecordProcessor(name: string, environment: string, token: string): LogRecordProcessor;
+import { type BeforeSendHook } from "./before-send.js";
+import { type RedactOptions } from "./redaction.js";
+export interface FoamIngestOptions {
+    readonly redact?: RedactOptions;
+    readonly beforeSend?: BeforeSendHook;
+}
+export declare function createFoamIngestSpanProcessor(name: string, environment: string, token: string, options?: FoamIngestOptions): SpanProcessor;
+export declare function createFoamIngestLogRecordProcessor(name: string, environment: string, token: string, options?: FoamIngestOptions): LogRecordProcessor;
 export declare function createFoamIngestMetricReader(name: string, environment: string, token: string): PeriodicExportingMetricReader;

package/dist/ingest.js

@@ -8,11 +8,19 @@ const sdk_logs_1 = require("@opentelemetry/sdk-logs");
 const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
 const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const api_logs_1 = require("@opentelemetry/api-logs");
+const before_send_js_1 = require("./before-send.js");
 const constants_js_1 = require("./constants.js");
 const report_js_1 = require("./report.js");
 const exporters_js_1 = require("./exporters.js");
 const logs_js_1 = require("./logs.js");
+const redaction_js_1 = require("./redaction.js");
 const state_js_1 = require("./state.js");
+function prepareOptions(options) {
+    return {
+        redaction: (0, redaction_js_1.resolveRedactionConfig)(options.redact),
+        beforeSend: (0, before_send_js_1.resolveBeforeSend)(options.beforeSend),
+    };
+}
 function prepareStamp(name, environment, token) {
     if (!name?.trim() || !environment?.trim() || !token) {
         throw new Error(`${constants_js_1.FOAM_IDENTIFIER_NAME}: name, environment, and token are required`);
@@ -21,7 +29,7 @@ function prepareStamp(name, environment, token) {
         stamp: {
             [semantic_conventions_1.ATTR_SERVICE_NAME]: name,
             [semantic_conventions_1.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment,
-            [constants_js_1.FOAM_INGEST_HOST]: constants_js_1.FOAM_INGEST_HOST,
+            [constants_js_1.ATTR_FOAM_INGEST_HOST]: constants_js_1.FOAM_INGEST_HOST,
         },
     };
 }
@@ -36,18 +44,19 @@ function reportIngestSignal(signal, name, environment, token) {
         message: `ingest ${signal} processor attached`,
     });
 }
-function createFoamIngestSpanProcessor(name, environment, token) {
+function createFoamIngestSpanProcessor(name, environment, token, options = {}) {
     const { stamp } = prepareStamp(name, environment, token);
-    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(token, stamp));
+    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(token, stamp, prepareOptions(options)));
     reportIngestSignal(state_js_1.Signals.traces, name, environment, token);
     return processor;
 }
-function createFoamIngestLogRecordProcessor(name, environment, token) {
+function createFoamIngestLogRecordProcessor(name, environment, token, options = {}) {
     const { stamp } = prepareStamp(name, environment, token);
+    const prepared = prepareOptions(options);
     const processor = new sdk_logs_1.BatchLogRecordProcessor({
-        exporter: new exporters_js_1.FoamLogExporter(token, stamp),
+        exporter: new exporters_js_1.FoamLogExporter(token, stamp, prepared),
     });
-    (0, logs_js_1.ensureFoamLoggerProvider)(name, environment, token, stamp);
+    (0, logs_js_1.ensureFoamLoggerProvider)(name, environment, token, stamp, prepared);
     reportIngestSignal(state_js_1.Signals.logs, name, environment, token);
     return processor;
 }

package/dist/init.d.ts

@@ -3,6 +3,8 @@ import { type Instrumentation } from "@opentelemetry/instrumentation";
 import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { type MetricReader } from "@opentelemetry/sdk-metrics";
 import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { type BeforeSendHook } from "./before-send.js";
+import { type RedactOptions } from "./redaction.js";
 export interface InitOptions {
     name: string;
     environment: string;
@@ -12,6 +14,8 @@ export interface InitOptions {
     disableLogSending?: boolean;
     networkCapture?: "off" | "basic" | "advanced";
     enabled?: boolean;
+    redact?: RedactOptions;
+    beforeSend?: BeforeSendHook;
     additionalInstrumentations?: readonly Instrumentation[];
     additionalSpanProcessors?: readonly SpanProcessor[];
     additionalLogRecordProcessors?: readonly LogRecordProcessor[];

package/dist/init.js

@@ -13,11 +13,15 @@ const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const report_js_1 = require("./report.js");
 const exporters_js_1 = require("./exporters.js");
 const instrumentations_js_1 = require("./instrumentations.js");
+const before_send_js_1 = require("./before-send.js");
 const logs_js_1 = require("./logs.js");
+const redaction_js_1 = require("./redaction.js");
 const state_js_1 = require("./state.js");
-// TODO(pcga11): conflicts, redact and beforeSend handling pending.
+// TODO(pcga11): conflicts handling pending.
 function init(options) {
     const { sampleRate = 1, disableLogSending = false, networkCapture = "basic", enabled = true, } = options;
+    const redactionConfig = (0, redaction_js_1.resolveRedactionConfig)(options.redact);
+    const beforeSend = (0, before_send_js_1.resolveBeforeSend)(options.beforeSend);
     // pcga11: Set params before any early return so every state is reported, including failed or disabled attempts.
     (0, state_js_1.setParams)({ name: options.name, environment: options.environment });
     // pcga11: We keep this option because companies often want to turn the integration off in specific envs
@@ -54,11 +58,20 @@ function init(options) {
         });
         return;
     }
+    if (!Number.isFinite(sampleRate) || sampleRate < 0 || sampleRate > 1) {
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.ERROR,
+            message: 'Parameter sampleRate must be a finite number between 0 and 1',
+        });
+        return;
+    }
     // pcga11: Hoisted so the catch block can shut down providers whose batch/periodic
     // export timers started in their constructors, even when init fails midway.
     let tracerProvider;
     let meterProvider;
     try {
+        (0, redaction_js_1.setActiveRedactionConfig)(redactionConfig);
         const resource = (0, resource_js_1.createFoamResource)(options.name, options.environment, options.version, options.additionalResourceAttributes);
         // pcga11: The context manager is what makes the "current" context (active span, baggage)
         // follow execution across await/callback boundaries, via Node's AsyncLocalStorage. Without
@@ -83,7 +96,10 @@ function init(options) {
                 root: new sdk_trace_base_1.TraceIdRatioBasedSampler(sampleRate),
             }),
             spanProcessors: [
-                new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(options.token)),
+                new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(options.token, undefined, {
+                    redaction: redactionConfig,
+                    beforeSend,
+                })),
                 ...(options.additionalSpanProcessors ?? []),
             ],
         });
@@ -100,7 +116,10 @@ function init(options) {
             resource,
             processors: [
                 new sdk_logs_1.BatchLogRecordProcessor({
-                    exporter: new exporters_js_1.FoamLogExporter(options.token),
+                    exporter: new exporters_js_1.FoamLogExporter(options.token, undefined, {
+                        redaction: redactionConfig,
+                        beforeSend,
+                    }),
                 }),
                 ...(options.additionalLogRecordProcessors ?? []),
             ],

package/dist/logs.d.ts

@@ -1,9 +1,10 @@
 import type { Attributes } from "@opentelemetry/api";
 import { SeverityNumber } from "@opentelemetry/api-logs";
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { type FoamExporterOptions } from "./exporters.js";
 export declare function setFoamLoggerProvider(provider: LoggerProvider): void;
 export declare function getFoamLoggerProvider(): LoggerProvider | undefined;
 export declare function clearFoamLoggerProvider(): void;
-export declare function ensureFoamLoggerProvider(name: string, environment: string, token: string, stamp?: Attributes): LoggerProvider;
+export declare function ensureFoamLoggerProvider(name: string, environment: string, token: string, stamp?: Attributes, options?: FoamExporterOptions): LoggerProvider;
 export declare const log: (body: string, severityNumber?: SeverityNumber, attributes?: Attributes) => void;
 export { SeverityNumber };

package/dist/logs.js

@@ -25,7 +25,7 @@ function getFoamLoggerProvider() {
 function clearFoamLoggerProvider() {
     foamLoggerProvider = undefined;
 }
-function ensureFoamLoggerProvider(name, environment, token, stamp) {
+function ensureFoamLoggerProvider(name, environment, token, stamp, options) {
     const existing = foamLoggerProvider;
     if (existing) {
         return existing;
@@ -34,7 +34,7 @@ function ensureFoamLoggerProvider(name, environment, token, stamp) {
         resource: (0, resource_js_1.createFoamResource)(name, environment),
         processors: [
             new sdk_logs_1.BatchLogRecordProcessor({
-                exporter: new exporters_js_1.FoamLogExporter(token, stamp),
+                exporter: new exporters_js_1.FoamLogExporter(token, stamp, options),
             }),
         ],
     });

package/dist/network-capture/collector.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BodyCollector = void 0;
 exports.setHeaderAttributes = setHeaderAttributes;
@@ -6,7 +39,7 @@ const api_1 = require("@opentelemetry/api");
 const api_logs_1 = require("@opentelemetry/api-logs");
 const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
 const node_crypto_1 = require("node:crypto");
-const node_zlib_1 = require("node:zlib");
+const zlib = __importStar(require("node:zlib"));
 const constants_js_1 = require("../constants.js");
 const utils_js_1 = require("../utils.js");
 const redact_js_1 = require("./redact.js");
@@ -78,31 +111,45 @@ function bodyByteLength(value, encoding) {
 function decodeBody(bytes, contentEncoding) {
     if (contentEncoding === undefined)
         return bytes;
-    const encoding = headerValues(contentEncoding)[0]?.toLowerCase().trim();
-    if (!encoding || encoding === "identity")
+    const encodings = headerValues(contentEncoding)
+        .flatMap((value) => value.split(","))
+        .map((value) => value.trim().toLowerCase())
+        .filter((value) => value && value !== "identity");
+    if (encodings.length === 0)
         return bytes;
-    // maxOutputLength turns a decompression bomb into a caught throw instead
-    // of an unrecoverable synchronous OOM allocation.
     const limits = { maxOutputLength: constants_js_1.NETWORK_BODY_MAX_DECODE_BYTES };
+    let decoded = bytes;
     try {
-        if (encoding === "gzip" || encoding === "x-gzip") {
-            return (0, node_zlib_1.gunzipSync)(bytes, limits);
-        }
-        if (encoding === "deflate") {
-            try {
-                return (0, node_zlib_1.inflateSync)(bytes, limits);
+        for (const encoding of encodings.reverse()) {
+            if (encoding === "gzip" || encoding === "x-gzip") {
+                decoded = zlib.gunzipSync(decoded, limits);
+            }
+            else if (encoding === "deflate") {
+                try {
+                    decoded = zlib.inflateSync(decoded, limits);
+                }
+                catch {
+                    decoded = zlib.unzipSync(decoded, limits);
+                }
             }
-            catch {
-                return (0, node_zlib_1.unzipSync)(bytes, limits);
+            else if (encoding === "br") {
+                decoded = zlib.brotliDecompressSync(decoded, limits);
+            }
+            else if (encoding === "zstd") {
+                const decompress = zlib.zstdDecompressSync;
+                if (!decompress)
+                    return undefined;
+                decoded = decompress(decoded, limits);
+            }
+            else {
+                return undefined;
             }
         }
-        if (encoding === "br")
-            return (0, node_zlib_1.brotliDecompressSync)(bytes, limits);
+        return decoded;
     }
     catch {
         return undefined;
     }
-    return undefined;
 }
 function textEncoding(contentType) {
     const raw = headerValues(contentType)[0];
@@ -113,20 +160,18 @@ function textEncoding(contentType) {
     const charset = parts
         .find((part) => part.toLowerCase().startsWith("charset="))
         ?.slice("charset=".length)
+        .trim()
+        .replace(/^["']|["']$/g, "")
         .toLowerCase();
-    const isText = media.startsWith("text/") ||
-        media.endsWith("/json") ||
-        media.endsWith("+json") ||
-        media.endsWith("/xml") ||
-        media.endsWith("+xml") ||
-        media.endsWith("/yaml") ||
-        media.endsWith("+yaml") ||
-        media === "application/x-www-form-urlencoded" ||
-        Boolean(charset);
+    const isText = (0, redact_js_1.isTextualBodyMediaType)(media) || Boolean(charset);
     if (!isText)
         return undefined;
     if (charset && Buffer.isEncoding(charset))
         return charset;
+    if (charset === "iso-8859-1" || charset === "windows-1252")
+        return "latin1";
+    if (media.startsWith("multipart/"))
+        return "latin1";
     return "utf8";
 }
 // Last index such that `buf.subarray(0, end)` is complete UTF-8, capped at `max`.
@@ -283,6 +328,7 @@ class BodyCollector {
         // the span; binary uses the same `http.*.body.content` name on the event.
         let binaryContent;
         let chunkSource = wire;
+        let chunkSourceIsDecodedText = false;
         if (wire !== undefined) {
             const decoded = decodeBody(wire, headers["content-encoding"]);
             if (decoded === undefined) {
@@ -298,6 +344,7 @@ class BodyCollector {
                         // redacted, so the (possibly compressed) wire bytes are replaced
                         // with the redacted text.
                         chunkSource = Buffer.from(redacted.text, encoding);
+                        chunkSourceIsDecodedText = true;
                     }
                 }
                 else {
@@ -319,10 +366,18 @@ class BodyCollector {
             [constants_js_1.ATTR_FOAM_HTTP_BODY_TRUNCATED]: this.truncated,
             [constants_js_1.ATTR_FOAM_HTTP_BODY_OUTCOME]: outcome,
             [this.attr.size]: this.observedBytes,
-            [constants_js_1.ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES]: this.capturedBytes,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES]: chunkSourceIsDecodedText
+                ? (chunkSource?.byteLength ?? 0)
+                : this.capturedBytes,
             [constants_js_1.ATTR_FOAM_HTTP_BODY_CHUNK_COUNT]: chunks.length,
         };
         for (const name of ["content-type", "content-encoding"]) {
+            if (name === "content-encoding" &&
+                chunkSourceIsDecodedText &&
+                headers[name] !== undefined) {
+                common[this.attr.header(name)] = ["identity"];
+                continue;
+            }
             if (headers[name] !== undefined) {
                 common[this.attr.header(name)] = headerValues(headers[name]);
             }

package/dist/network-capture/redact.d.ts

@@ -3,4 +3,7 @@ export interface RedactionResult {
     readonly changed: boolean;
 }
 export declare function isSensitiveBodyKey(key: string): boolean;
+export declare function isNdjsonMediaType(media: string): boolean;
+export declare function isJsonSequenceMediaType(media: string): boolean;
+export declare function isTextualBodyMediaType(media: string): boolean;
 export declare function redactBodyText(text: string, contentType: unknown): RedactionResult;