hypertrace-publisher

@hypertrace/nodejsagent

var __importDefault = (this && this.__importDefault) || function (mod) {

    return (mod && mod.__esModule) ? mod : { "default": mod };

Object.defineProperty(exports, "__esModule", { value: true });

exports.HttpInstrumentationWrapper = void 0;

const api_1 = require("@opentelemetry/api");

const AttrWrapper_1 = require("./AttrWrapper");

const BodyCapture_1 = require("./BodyCapture");

const config_1 = require("../config/config");

const Registry_1 = require("../filter/Registry");

const Filter_1 = require("../filter/Filter");

const core_1 = require("@opentelemetry/core");

const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");

const Framework_1 = require("./Framework");

const HypertraceAgent_1 = require("../HypertraceAgent");

const http_2 = __importDefault(require("http"));

const node_stream_1 = __importDefault(require("node:stream"));

const _RECORDABLE_CONTENT_TYPES = ['application/json', 'application/graphql', 'application/x-www-form-urlencoded'];

        this.IncomingRequestHook = this.incomingRequestHook.bind(this);

        this.OutgoingRequestHook = this.outgoingRequestHook.bind(this);

        this.CustomAttrs = this.customAttrs.bind(this);

        this.RespHook = this.respHook.bind(this);

        // We need to collect request data before sending span to Filter API

        this.setIncomingRequestAttributes = (span, request) => {

            const { localAddress, localPort, remoteAddress, remotePort } = socket;

            const rpcMetadata = (0, core_1.getRPCMetadata)(api_1.context.active());

                [semantic_conventions_1.SemanticAttributes.NET_HOST_IP]: localAddress,

                [semantic_conventions_1.SemanticAttributes.NET_HOST_PORT]: localPort,

                [semantic_conventions_1.SemanticAttributes.NET_PEER_IP]: remoteAddress,

                [semantic_conventions_1.SemanticAttributes.NET_PEER_PORT]: remotePort,

            if ((rpcMetadata === null || rpcMetadata === void 0 ? void 0 : rpcMetadata.type) === core_1.RPCType.HTTP && rpcMetadata.route !== undefined) {

                attributes[semantic_conventions_1.SemanticAttributes.HTTP_ROUTE] = rpcMetadata.route;

            span.setAttributes(attributes);

        let dataCapture = this.agentConfig.data_capture;

        this.requestHeaderCaptureEnabled = dataCapture.http_headers.request;

        this.responseHeaderCaptureEnabled = dataCapture.http_headers.response;

        this.requestBodyCaptureEnabled = dataCapture.http_body.request;

        this.responseBodyCaptureEnabled = dataCapture.http_body.response;

        this.maxBodySizeBytes = dataCapture.body_max_size_bytes;

        if (this.requestHeaderCaptureEnabled) {

            let headers = request instanceof http_1.IncomingMessage ? request.headers : request.getHeaders();

                span.setAttribute(`http.request.header.${key}`, headers[key]);

        if (request instanceof http_1.ClientRequest) {

            request.hypertraceSpan = span;

            this.setIncomingRequestAttributes(span, request);

            let headers = request.headers;

            if (request.socket && request.socket.server instanceof http_2.default.Server) {

                span.setAttribute("http.scheme", "http");

                span.setAttribute("http.scheme", "https");

            let filterResult = Registry_1.Registry.getInstance().applyFilters(span, request.url, headers, undefined, Filter_1.REQUEST_TYPE.HTTP);

                if (Framework_1.Framework.getInstance().isPureExpress()) {

                    HypertraceAgent_1.hypertraceDomain.run(function () {

                        throw (0, Filter_1.filterError)();

            let bodyCapture = new BodyCapture_1.BodyCapture(config_1.Config.getInstance().config.data_capture.body_max_size_bytes, config_1.Config.getInstance().config.data_capture.body_max_processing_size_bytes);

            if (this.shouldCaptureBody(config_1.Config.getInstance().config.data_capture.http_body.request, headers)) {

                if (!Framework_1.Framework.getInstance().anyFrameworks() || Framework_1.Framework.getInstance().isExpressBased() || Framework_1.Framework.getInstance().isPureExpress()) {

                    const listener = (chunk) => {

                        bodyCapture.appendData(chunk);

                    request.on("data", listener);

                    request.once("end", () => {

                        HypertraceAgent_1.hypertraceDomain.run(function () {

                            request.removeListener('data', listener);

                            let bodyString = bodyCapture.dataString();

                            span.setAttribute('http.request.body', bodyString);

                            // @ts-ignore

                            let filterResult = Registry_1.Registry.getInstance().applyFilters(span, request.url, headers, bodyCapture.processableString(), Filter_1.REQUEST_TYPE.HTTP);

                            if (filterResult) {

                                // we need to use domains to catch an async exception

                                // if the end user app does not have any middlewares reading request body,

                                // applying filters will not have anywhere to propagate the error

                                // so we will see unintended status code / message pair

                                // ex: 200 Forbidden

                                // additionally, if user is using event listeners on request data,

                                // since body read occurs on event emission if our event emitter determines to filter request

                                // user event listeners cannot be prevented from running(or replaced, or mutated) - this will cause

                                // errors since we've already written + closed the response

                                // throwing an uncaught error that is bound within a domain allows us to achieve both:

                                // cancel request without it propagating further through the app &

                                // set the desired response

                                if (Framework_1.Framework.getInstance().isPureExpress()) {

                                    // @ts-ignore

                                    request.res.status(Filter_1.STATUS_CODE);

                                    request.res.end();

            let bodyCapture = new BodyCapture_1.BodyCapture(config_1.Config.getInstance().config.data_capture.body_max_size_bytes, 0);

            const listener = (chunk) => {

                bodyCapture.appendData(chunk);

            const originalEmit = response.emit;

            response.emit = function (eventName, ...args) {

                if (eventName === 'data') {

                    chunks.push(Buffer.from(args[0]));

                else if (eventName === 'end') {

                    const bodyBuffer = Buffer.concat(chunks);

                    let bodyString = bodyBuffer.toString('utf-8');

                    span.setAttribute("http.response.body", bodyString);

                    if (response.stream) {

                        response.stream = node_stream_1.default.Readable.from(bodyBuffer);

                return originalEmit.apply(response, [eventName, ...args]);

            response.on("data", listener);

                response.removeListener('data', listener);

                let bodyString = bodyCapture.dataString();

                span.setAttribute("http.response.body", bodyString);

    shouldCaptureBody(configField, headers) {

        let contentType = headers['content-type'];

        return HttpInstrumentationWrapper.isRecordableContentType(contentType);

    static isRecordableContentType(contentType) {

        if (contentType === undefined || contentType === null) {

        for (let recordableType of _RECORDABLE_CONTENT_TYPES) {

            if (contentType.includes(recordableType)) {

exports.HttpInstrumentationWrapper = HttpInstrumentationWrapper;

  "description": "Hypertrace Node.js Agent",

    "url": "git://github.com/hypertrace/nodejsagent"

    "@opentelemetry/exporter-trace-otlp-grpc": "0.49.1",

    "@opentelemetry/exporter-trace-otlp-http": "0.49.1",

    "@opentelemetry/exporter-zipkin": "1.22.0",

    "@opentelemetry/instrumentation-aws-lambda": "0.38.0",

    "@opentelemetry/instrumentation-express": "0.35.0",

    "@opentelemetry/instrumentation-graphql": "0.37.0",

    "@opentelemetry/instrumentation-grpc": "0.49.1",

    "@opentelemetry/instrumentation-hapi": "0.34.0",

    "@opentelemetry/instrumentation-http": "0.49.1",

    "@opentelemetry/instrumentation-koa": "0.37.0",

    "@opentelemetry/instrumentation-mongodb": "0.39.0",

    "@opentelemetry/instrumentation-mongoose": "0.35.0",

    "@opentelemetry/instrumentation-mysql": "0.35.0",

    "@opentelemetry/instrumentation-mysql2": "0.35.0",

    "@opentelemetry/instrumentation-pg": "0.38.0",

    "@opentelemetry/propagator-b3": "1.22.0",

    "@opentelemetry/sdk-trace-node": "1.22.0",

    "@nestjs/platform-express": "^8.1.1",

    "@semantic-release/github": "^8.0.1",

    "next-version": "semantic-release --dry-run | grep 'The next release version is' | grep -oEi \"\\s([0-9].*)$\" | xargs",

    "test": "env TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' HT_LOG_LEVEL=DEBUG mocha -r ts-node/register 'test/**/*.ts' --exclude 'test/integration/**/*.*'",

    "coverage": "nyc --reporter=lcov npm run test",

    "generate_pb": "pbjs --keep-case -t static-module -w default -o src/config/generated.js agent-config/proto/hypertrace/agent/config/v1/config.proto && pbts --keep-case -o ./src/config/generated.d.ts ./src/config/generated.js"

		{
		"name": "@hypertrace/nodejsagent",
		"version": "1.8.0",
		"version": "1.8.1-dev",
		"description": "Hypertrace Node.js Agent",
		@@ -5,0 +5,0 @@ "author": "Traceable Inc.",

New alerts

Improved metrics

Worsened metrics

		@@ -19,2 +19,3 @@ "use strict";
		const http_2 = __importDefault(require("http"));
		const node_stream_1 = __importDefault(require("node:stream"));
		const _RECORDABLE_CONTENT_TYPES = ['application/json', 'application/graphql', 'application/x-www-form-urlencoded'];
		@@ -178,11 +179,20 @@ class HttpInstrumentationWrapper {
		let bodyCapture = new BodyCapture_1.BodyCapture(config_1.Config.getInstance().config.data_capture.body_max_size_bytes, 0);
		const listener = (chunk) => {
		bodyCapture.appendData(chunk);
		const chunks = [];
		const originalEmit = response.emit;
		response.emit = function (eventName, ...args) {
		if (eventName === 'data') {
		chunks.push(Buffer.from(args[0]));
		}
		else if (eventName === 'end') {
		const bodyBuffer = Buffer.concat(chunks);
		let bodyString = bodyBuffer.toString('utf-8');
		span.setAttribute("http.response.body", bodyString);
		// @ts-ignore
		if (response.stream) {
		// @ts-ignore
		response.stream = node_stream_1.default.Readable.from(bodyBuffer);
		}
		}
		return originalEmit.apply(response, [eventName, ...args]);
		};
		response.on("data", listener);
		response.once("end", () => {
		response.removeListener('data', listener);
		let bodyString = bodyCapture.dataString();
		span.setAttribute("http.response.body", bodyString);
		});
		}
		@@ -189,0 +199,0 @@ }