@multiplayer-app/session-recorder-common 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2024 Multiplayer Software, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,230 @@
+# Session Recorder OpenTelemetry Core
+
+This package provides implementations of the OpenTelemetry API for trace and metrics. It's intended for use both on the server and in the browser.
+
+## Built-in Implementations
+
+- [Session Recorder OpenTelemetry Core](#session-recorder-opentelemetry-core)
+  - [Built-in Implementations](#built-in-implementations)
+    - [Constants](#constants)
+    - [Setup opentelemetry for capturing http request/response body](#session-recorder-http-instrumentation-hooks-node)
+    - [Session Recorder Http Trace exporter web](#session-recorder-http-trace-exporter-web)
+    - [Session Recorder id generator](#session-recorder-id-generator)
+    - [Trace id ratio based sampler](#trace-id-ratio-based-sampler)
+    - [Helper for capturing exception in session recording](#helper-for-capturing-exceptions)
+    - [Helpers for adding content to session recording](#helper-for-setting-attributes-to-span)
+  - [License](#license)
+
+### Constants
+
+```javascript
+import {
+  MULTIPLAYER_TRACE_DOC_PREFIX,
+  MULTIPLAYER_TRACE_DEBUG_PREFIX,
+  MULTIPLAYER_OTEL_DEFAULT_TRACES_EXPORTER_URL,
+  MULTIPLAYER_OTEL_DEFAULT_LOGS_EXPORTER_URL,
+  MULTIPLAYER_ATTRIBUTE_PREFIX,
+  MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE,
+  ATTR_MULTIPLAYER_DEBUG_SESSION,
+  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY,
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
+  ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS,
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS,
+  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING,
+  ATTR_MULTIPLAYER_RPC_REQUEST_MESSAGE,
+  ATTR_MULTIPLAYER_RPC_RESPONSE_MESSAGE,
+  ATTR_MULTIPLAYER_GRPC_REQUEST_MESSAGE,
+  ATTR_MULTIPLAYER_GRPC_RESPONSE_MESSAGE,
+  ATTR_MULTIPLAYER_MESSAGING_MESSAGE_BODY,
+} from '@multiplayer-app/session-recorder-opentelemetry'
+```
+
+### Setup opentelemetry for capturing http request/response body
+
+Session Recorder hooks for nodejs http instrumentation for injecting http request/response headers and payload to span.
+
+```javascript
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
+import { type Instrumentation } from '@opentelemetry/instrumentation'
+import { SessionRecorderHttpInstrumentationHooks } from '@multiplayer-app/session-recorder-opentelemetry'
+
+export const instrumentations: Instrumentation[] = getNodeAutoInstrumentations({
+  '@opentelemetry/instrumentation-http': {
+    enabled: true,
+    responseHook: SessionRecorderHttpInstrumentationHooks.responseHook({
+      maxPayloadSizeBytes: 1000,
+      uncompressPayload: true,
+      captureHeaders: true,
+      captureBody: true,
+      isMaskingEnabled: true,
+      maskBody: (data, span) => {
+        // mask logic here
+        return data
+      },
+      maskHeaders: (data, span) => {
+        // mask logic here
+        return data
+      },
+      maskBodyFieldsList: ['password', 'card'],
+      maskHeadersList: ['x-trace-id'],
+      headersToInclude: ['Set-Cookie', 'Authorization'],
+      headersToExclude: ['Cookie'],
+    }),
+    requestHook: SessionRecorderHttpInstrumentationHooks.requestHook({
+      maxPayloadSizeBytes: 1000,
+      captureHeaders: true,
+      captureBody: true,
+      isMaskingEnabled: true,
+      maskBody: (data, span) => {
+        // mask logic here
+        return data
+      },
+      maskHeaders: (data, span) => {
+        // mask logic here
+        return data
+      },
+      maskBodyFieldsList: ['password', 'card'],
+      maskHeadersList: ['x-trace-id'],
+      headersToInclude: ['Set-Cookie', 'Authorization'],
+      headersToExclude: ['Cookie'],
+    }),
+  },
+)
+```
+
+### Session Recorder Http Trace exporter web
+
+```javascript
+import { BatchSpanProcessor, WebTracerProvider } from '@opentelemetry/sdk-trace-web'
+import { SessionRecorderHttpTraceExporterBrowser } from '@multiplayer-app/session-recorder-opentelemetry'
+
+const collectorOptions = {
+  url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is https://api.multiplayer.app/v1/traces
+  apiKey: '<multiplayer-otlp-key>' // api key from multiplayer integration
+}
+
+const exporter = new SessionRecorderHttpTraceExporterBrowser(collectorOptions)
+const provider = new WebTracerProvider({
+  spanProcessors: [
+    new BatchSpanProcessor(exporter, {
+      // The maximum queue size. After the size is reached spans are dropped.
+      maxQueueSize: 100,
+      // The maximum batch size of every export. It must be smaller or equal to maxQueueSize.
+      maxExportBatchSize: 10,
+      // The interval between two consecutive exports
+      scheduledDelayMillis: 500,
+      // How long the export can run before it is cancelled
+      exportTimeoutMillis: 30000
+    })
+  ]
+})
+
+provider.register()
+```
+
+### Session Recorder id generator
+
+
+```javascript
+import { BatchSpanProcessor, WebTracerProvider } from '@opentelemetry/sdk-trace-web'
+import { SessionRecorderIdGenerator, SessionRecorderHttpTraceExporterBrowser } from '@multiplayer-app/session-recorder-opentelemetry'
+
+const idGenerator = new SessionRecorderIdGenerator({ autoDocTracesRatio: 0.05 })
+
+const collectorOptions = {
+  url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is https://api.multiplayer.app/v1/traces
+  apiKey: '<multiplayer-otlp-key>' // api key from multiplayer integration
+}
+
+const exporter = new SessionRecorderHttpTraceExporterBrowser(collectorOptions)
+const provider = new WebTracerProvider({
+  spanProcessors: [
+    new BatchSpanProcessor(exporter, {
+      // The maximum queue size. After the size is reached spans are dropped.
+      maxQueueSize: 100,
+      // The maximum batch size of every export. It must be smaller or equal to maxQueueSize.
+      maxExportBatchSize: 10,
+      // The interval between two consecutive exports
+      scheduledDelayMillis: 500,
+      // How long the export can run before it is cancelled
+      exportTimeoutMillis: 30000
+    })
+  ],
+  idGenerator
+})
+
+idGenerator.setSessionId('<multiplayer-debug-session-short-id>')
+```
+
+### Trace id ratio based sampler
+
+Session Recorder sampler will always sample traces with appropriate prefixes, other traces will be sampled using ration provided to constructor.
+
+```javascript
+import { BatchSpanProcessor, WebTracerProvider } from '@opentelemetry/sdk-trace-web'
+import { SessionRecorderTraceIdRatioBasedSampler, SessionRecorderHttpTraceExporterBrowser } from '@multiplayer-app/session-recorder-opentelemetry'
+
+const collectorOptions = {
+  url: '<opentelemetry-collector-url>', // url is optional and can be omitted - default is https://api.multiplayer.app/v1/traces
+  apiKey: '<multiplayer-otlp-key>' // api key from multiplayer integration
+}
+
+const exporter = new SessionRecorderHttpTraceExporterBrowser(collectorOptions)
+const provider = new WebTracerProvider({
+  spanProcessors: [
+    new BatchSpanProcessor(exporter, {
+      // The maximum queue size. After the size is reached spans are dropped.
+      maxQueueSize: 100,
+      // The maximum batch size of every export. It must be smaller or equal to maxQueueSize.
+      maxExportBatchSize: 10,
+      // The interval between two consecutive exports
+      scheduledDelayMillis: 500,
+      // How long the export can run before it is cancelled
+      exportTimeoutMillis: 30000
+    })
+  ],
+  sampler: new SessionRecorderTraceIdRatioBasedSampler(0.05)
+})
+```
+
+### Helper for capturing exception in session recording
+
+```javascript
+import { SessionRecorderSdk } from '@multiplayer-app/session-recorder-opentelemetry'
+
+const error = new Error('Some text here')
+
+SessionRecorderSdk.captureException(error)
+```
+
+### Helpers for adding content to session recording
+
+```javascript
+import { SessionRecorderSdk } from '@multiplayer-app/session-recorder-opentelemetry'
+
+SessionRecorderSdk.setAttribute('{{SOME_KEY}}', '{{SOME_VALUE}}')
+
+// following helpers do masking of sensitive fields
+SessionRecorderSdk.setHttpRequestBody('{{ANY_REQUEST_PAYLOAD_HERE}}')
+
+SessionRecorderSdk.setHttpRequestHeaders({ Cookie: '...', Authorization: '...'})
+
+SessionRecorderSdk.setHttpResponseBody({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+SessionRecorderSdk.setHttpResponseHeaders({ 'Set-Cookie': '...' })
+
+SessionRecorderSdk.setMessageBody({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+SessionRecorderSdk.setRpcRequestMessage({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+SessionRecorderSdk.setRpcResponseMessage({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+SessionRecorderSdk.setGrpcRequestMessage({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+SessionRecorderSdk.setGrpcResponseMessage({some_payload: '{{ANY_REQUEST_PAYLOAD_HERE}}'})
+
+```
+
+## License
+
+MIT - See [LICENSE](./LICENSE) for more information.

package/dist/esm/SessionRecorderHttpInstrumentationHooksNode.d.ts

@@ -0,0 +1,35 @@
+import type { IncomingMessage, ServerResponse, ClientRequest } from 'http';
+import type { Span } from '@opentelemetry/api';
+interface HttpResponseHookOptions {
+    maxPayloadSizeBytes?: number;
+    schemifyDocSpanPayload?: boolean;
+    uncompressPayload?: boolean;
+    captureHeaders?: boolean;
+    captureBody?: boolean;
+    isMaskingEnabled?: boolean;
+    maskBody?: (arg: any, span: Span) => any;
+    maskHeaders?: (arg: any, span: Span) => any;
+    maskBodyFieldsList?: string[];
+    maskHeadersList?: string[];
+    headersToInclude?: string[];
+    headersToExclude?: string[];
+}
+interface HttpRequestHookOptions {
+    maxPayloadSizeBytes?: number;
+    schemifyDocSpanPayload?: boolean;
+    captureHeaders?: boolean;
+    captureBody?: boolean;
+    isMaskingEnabled?: boolean;
+    maskBody?: (arg: any, span: Span) => any;
+    maskHeaders?: (arg: any, span: Span) => any;
+    maskBodyFieldsList?: string[];
+    maskHeadersList?: string[];
+    headersToInclude?: string[];
+    headersToExclude?: string[];
+}
+export declare const SessionRecorderHttpInstrumentationHooksNode: {
+    responseHook: (options?: HttpResponseHookOptions) => (span: Span, response: IncomingMessage | ServerResponse) => void;
+    requestHook: (options?: HttpRequestHookOptions) => (span: Span, request: ClientRequest | IncomingMessage) => void;
+};
+export {};
+//# sourceMappingURL=SessionRecorderHttpInstrumentationHooksNode.d.ts.map

package/dist/esm/SessionRecorderHttpInstrumentationHooksNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionRecorderHttpInstrumentationHooksNode.d.ts","sourceRoot":"","sources":["../../src/SessionRecorderHttpInstrumentationHooksNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,aAAa,EACd,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAoB9C,UAAU,uBAAuB;IAC/B,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAE3B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,GAAG,CAAA;IACxC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,GAAG,CAAA;IAE3C,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAE1B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B;AAED,UAAU,sBAAsB;IAC9B,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAEhC,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,GAAG,CAAA;IACxC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,GAAG,CAAA;IAE3C,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAE1B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B;AAqED,eAAO,MAAM,2CAA2C;6BAC9B,uBAAuB,YACtC,IAAI,YAAY,eAAe,GAAG,cAAc;4BAqIlC,sBAAsB,YACpC,IAAI,WAAW,aAAa,GAAG,eAAe;CA6FxD,CAAA"}

package/dist/esm/SessionRecorderHttpInstrumentationHooksNode.js

@@ -0,0 +1,355 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import * as zlib from 'zlib';
+import { ATTR_MULTIPLAYER_HTTP_REQUEST_BODY, ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS, ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY, ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS, MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE, ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING, MULTIPLAYER_TRACE_DEBUG_PREFIX, } from './constants.node';
+import { mask, schemify, isGzip, } from './sdk';
+import { sensitiveFields, sensitiveHeaders } from './sdk/mask';
+var setDefaultOptions = function (options) {
+    options.captureHeaders = 'captureHeaders' in options
+        ? options.captureHeaders
+        : true;
+    options.captureBody = 'captureBody' in options
+        ? options.captureBody
+        : true;
+    options.isMaskingEnabled = 'isMaskingEnabled' in options
+        ? options.isMaskingEnabled
+        : true;
+    options.schemifyDocSpanPayload = 'schemifyDocSpanPayload' in options
+        ? options.schemifyDocSpanPayload
+        : false;
+    options.uncompressPayload = 'uncompressPayload' in options
+        ? options.uncompressPayload
+        : true;
+    options.maskBody = options.maskBody || mask(__spreadArray(__spreadArray([], __read((Array.isArray(options.maskBodyFieldsList)
+        ? options.maskBodyFieldsList
+        : sensitiveFields)), false), __read((Array.isArray(options.maskHeadersList)
+        ? options.maskHeadersList
+        : sensitiveHeaders)), false));
+    options.maskHeaders = options.maskHeaders || mask(__spreadArray(__spreadArray([], __read((Array.isArray(options.maskBodyFieldsList)
+        ? options.maskBodyFieldsList
+        : sensitiveFields)), false), __read((Array.isArray(options.maskHeadersList)
+        ? options.maskHeadersList
+        : sensitiveHeaders)), false));
+    options.maxPayloadSizeBytes = options.maxPayloadSizeBytes || MULTIPLAYER_MAX_HTTP_REQUEST_RESPONSE_SIZE;
+    return options;
+};
+export var SessionRecorderHttpInstrumentationHooksNode = {
+    responseHook: function (options) {
+        if (options === void 0) { options = {}; }
+        return function (span, response) {
+            try {
+                var _options_1 = setDefaultOptions(options);
+                if (!_options_1.captureBody && !_options_1.captureHeaders) {
+                    return;
+                }
+                var _response_1 = response;
+                var traceId_1 = span.spanContext().traceId;
+                if (_response_1.setHeader) {
+                    _response_1.setHeader('X-Trace-Id', traceId_1);
+                }
+                var _a = __read([_response_1.write, _response_1.end], 2), oldWrite_1 = _a[0], oldEnd_1 = _a[1];
+                var chunks_1 = [];
+                if (_options_1.captureBody) {
+                    _response_1.write = function () {
+                        var restArgs = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            restArgs[_i] = arguments[_i];
+                        }
+                        chunks_1.push(Buffer.from(restArgs[0]));
+                        // eslint-disable-next-line
+                        // @ts-ignore
+                        oldWrite_1.apply(_response_1, restArgs);
+                    };
+                }
+                // eslint-disable-next-line
+                // @ts-ignore
+                _response_1.end = function () {
+                    var restArgs = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        restArgs[_i] = arguments[_i];
+                    }
+                    return __awaiter(this, void 0, void 0, function () {
+                        var responseBuffer, responseBody, skipResponseBodyModification, dezippedBuffer, headers, _headers, _a, _b, headerName, _c, _d, headerName, stringifiedHeaders;
+                        var e_1, _e, e_2, _f;
+                        var _g, _h, _j;
+                        return __generator(this, function (_k) {
+                            switch (_k.label) {
+                                case 0:
+                                    if (_options_1.captureBody && restArgs[0]) {
+                                        chunks_1.push(Buffer.from(restArgs[0]));
+                                    }
+                                    responseBuffer = Buffer.concat(chunks_1);
+                                    if (!(_options_1.captureBody
+                                        && responseBuffer.byteLength > 0
+                                        && responseBuffer.byteLength < _options_1.maxPayloadSizeBytes)) return [3 /*break*/, 6];
+                                    responseBody = void 0;
+                                    skipResponseBodyModification = false;
+                                    if (!isGzip(responseBuffer)) return [3 /*break*/, 4];
+                                    if (!_options_1.uncompressPayload) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, new Promise(function (resolve) { return zlib
+                                            .gunzip(responseBuffer, function (err, dezipped) {
+                                            if (err) {
+                                                return resolve(Buffer.from(''));
+                                            }
+                                            else {
+                                                return resolve(dezipped);
+                                            }
+                                        }); })];
+                                case 1:
+                                    dezippedBuffer = _k.sent();
+                                    responseBody = dezippedBuffer.toString('utf-8');
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY_ENCODING, 'gzip');
+                                    skipResponseBodyModification = true;
+                                    responseBody = responseBuffer.toString('hex');
+                                    _k.label = 3;
+                                case 3: return [3 /*break*/, 5];
+                                case 4:
+                                    responseBody = responseBuffer.toString('utf-8');
+                                    _k.label = 5;
+                                case 5:
+                                    if (!skipResponseBodyModification) {
+                                        if (traceId_1.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+                                            && _options_1.isMaskingEnabled) {
+                                            responseBody = _options_1.maskBody(responseBody, span);
+                                        }
+                                        else if (_options_1.schemifyDocSpanPayload) {
+                                            responseBody = schemify(responseBody);
+                                        }
+                                        else if (typeof responseBody !== 'string') {
+                                            responseBody = JSON.stringify(responseBody);
+                                        }
+                                    }
+                                    if (responseBody.length) {
+                                        span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY, responseBody);
+                                    }
+                                    _k.label = 6;
+                                case 6:
+                                    if (_options_1.captureHeaders) {
+                                        headers = _options_1.maskHeaders(_response_1.getHeaders(), span);
+                                        _headers = {};
+                                        if (!((_g = _options_1.headersToInclude) === null || _g === void 0 ? void 0 : _g.length)
+                                            && !((_h = _options_1.headersToExclude) === null || _h === void 0 ? void 0 : _h.length)) {
+                                            _headers = JSON.parse(JSON.stringify(headers));
+                                        }
+                                        else {
+                                            if (_options_1.headersToInclude) {
+                                                try {
+                                                    for (_a = __values(_options_1.headersToInclude), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                        headerName = _b.value;
+                                                        _headers[headerName] = headers[headerName];
+                                                    }
+                                                }
+                                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                                                    }
+                                                    finally { if (e_1) throw e_1.error; }
+                                                }
+                                            }
+                                            if ((_j = _options_1.headersToExclude) === null || _j === void 0 ? void 0 : _j.length) {
+                                                try {
+                                                    for (_c = __values(_options_1.headersToExclude), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                                        headerName = _d.value;
+                                                        delete _headers[headerName];
+                                                    }
+                                                }
+                                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                                                    }
+                                                    finally { if (e_2) throw e_2.error; }
+                                                }
+                                            }
+                                        }
+                                        stringifiedHeaders = JSON.stringify(_headers);
+                                        if (stringifiedHeaders === null || stringifiedHeaders === void 0 ? void 0 : stringifiedHeaders.length) {
+                                            span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS, stringifiedHeaders);
+                                        }
+                                    }
+                                    // eslint-disable-next-line
+                                    // @ts-ignore
+                                    return [2 /*return*/, oldEnd_1.apply(_response_1, restArgs)];
+                            }
+                        });
+                    });
+                };
+            }
+            catch (error) {
+                // eslint-disable-next-line
+                console.error('An error occured in multiplayer otlp http responseHook', error);
+            }
+        };
+    },
+    requestHook: function (options) {
+        if (options === void 0) { options = {}; }
+        return function (span, request) {
+            var e_3, _a, e_4, _b;
+            var _c, _d, _e, _f;
+            try {
+                var _options_2 = setDefaultOptions(options);
+                if (!_options_2.captureBody && !_options_2.captureHeaders) {
+                    return;
+                }
+                var traceId_2 = span.spanContext().traceId;
+                var _request = request;
+                if (_options_2.captureHeaders) {
+                    var _headers = {};
+                    if (!((_c = _options_2.headersToInclude) === null || _c === void 0 ? void 0 : _c.length)
+                        && !((_d = _options_2.headersToExclude) === null || _d === void 0 ? void 0 : _d.length)) {
+                        _headers = JSON.parse(JSON.stringify(_request.headers));
+                    }
+                    else {
+                        if (_options_2.headersToInclude) {
+                            try {
+                                for (var _g = __values(_options_2.headersToInclude), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                    var headerName = _h.value;
+                                    _headers[headerName] = _request.headers;
+                                }
+                            }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                            }
+                        }
+                        if ((_e = _options_2.headersToExclude) === null || _e === void 0 ? void 0 : _e.length) {
+                            try {
+                                for (var _j = __values(_options_2.headersToExclude), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                    var headerName = _k.value;
+                                    delete _headers[headerName];
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                        }
+                    }
+                    var headers = _options_2.maskHeaders(_headers, span);
+                    span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS, JSON.stringify(headers));
+                }
+                var contentType = (_f = _request === null || _request === void 0 ? void 0 : _request.headers) === null || _f === void 0 ? void 0 : _f['content-type'];
+                if (_options_2.captureBody
+                    && (contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json'))) {
+                    var body_1 = '';
+                    _request.on('data', function (chunk) {
+                        body_1 += chunk;
+                    });
+                    _request.on('end', function () {
+                        try {
+                            var requestBodySizeBytes = Buffer.byteLength(body_1, 'utf8');
+                            if (requestBodySizeBytes === 0
+                                || requestBodySizeBytes > _options_2.maxPayloadSizeBytes) {
+                                return;
+                            }
+                            var requestBody = body_1;
+                            if (!requestBody)
+                                return;
+                            if (traceId_2.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX)
+                                && _options_2.isMaskingEnabled) {
+                                requestBody = _options_2.maskBody(requestBody, span);
+                            }
+                            else if (_options_2.schemifyDocSpanPayload) {
+                                requestBody = schemify(requestBody);
+                            }
+                            else if (typeof requestBody !== 'string') {
+                                requestBody = JSON.stringify(requestBody);
+                            }
+                            if (requestBody === null || requestBody === void 0 ? void 0 : requestBody.length) {
+                                span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_BODY, requestBody);
+                            }
+                        }
+                        catch (err) {
+                            // eslint-disable-next-line
+                            console.error('[MULTIPLAYER-HTTP-REQ-HOOK] An error occured in multiplayer otlp http requestHook', err);
+                        }
+                    });
+                }
+            }
+            catch (error) {
+                // eslint-disable-next-line
+                console.error('An error occured in multiplayer otlp http requestHook', error);
+            }
+        };
+    },
+};
+//# sourceMappingURL=SessionRecorderHttpInstrumentationHooksNode.js.map