Release 1.6.1 (#73)

* feat: patch bump

* Esmodule support lambda (#72)

* Add method to manually wrap lambda handler

* Move to extension class

* fix test

* remove header diff across node

* add testg

* Handle err

Author: prodion23

lambda_layer/local.Dockerfile

@@ -1,4 +1,4 @@
-FROM amazon/aws-sam-cli-build-image-nodejs10.x
+FROM amazon/aws-sam-cli-build-image-nodejs14.x
 
 ADD . /workspace
 

src/HypertraceAgent.ts

@@ -3,7 +3,7 @@ import {isCompatible} from "./instrumentation/InstrumentationCompat";
 
 require('./instrumentation/instrumentation-patch');
 
-import {AwsLambdaInstrumentation} from "@opentelemetry/instrumentation-aws-lambda";
+import {ExtendedAwsLambdaInstrumentation} from "./instrumentation/ExtendedAwsLambdaInstrumentation";
 import {NodeTracerProvider} from '@opentelemetry/sdk-trace-node';
 import {BatchSpanProcessor, InMemorySpanExporter, SpanExporter} from '@opentelemetry/sdk-trace-base';
 import {ZipkinExporter} from '@opentelemetry/exporter-zipkin';
@@ -59,6 +59,13 @@ export class HypertraceAgent {
         logger.info("Successfully initialized Hypertrace Agent")
     }
 
+    instrumentLambda(handlerFunc) {
+        return ExtendedAwsLambdaInstrumentation.TraceLambda(handlerFunc, {
+            requestHook: LambdaRequestHook,
+            responseHook: LambdaResponseHook
+        }, this._provider)
+    }
+
     instrument() {
         hypertraceDomain.on('error', (er) => {
             // these should only be forbidden errors unless something is going wrong with our body capture
@@ -85,7 +92,7 @@ export class HypertraceAgent {
         }
 
         let instrumentations = [
-            new AwsLambdaInstrumentation({
+            new ExtendedAwsLambdaInstrumentation({
                 requestHook: LambdaRequestHook,
                 responseHook: LambdaResponseHook,
                 disableAwsContextPropagation: true

src/instrumentation/ExtendedAwsLambdaInstrumentation.ts

@@ -0,0 +1,64 @@
+import { AwsLambdaInstrumentation } from "@opentelemetry/instrumentation-aws-lambda";
+import {SemanticAttributes, SemanticResourceAttributes} from "@opentelemetry/semantic-conventions";
+import {SpanKind, SpanStatusCode, trace} from "@opentelemetry/api";
+import {
+    context as otelContext,
+} from '@opentelemetry/api';
+
+import {VERSION} from "@opentelemetry/instrumentation-aws-lambda/build/src/version"
+
+export class ExtendedAwsLambdaInstrumentation extends AwsLambdaInstrumentation {
+    public static TraceLambda(handler, config = {}, traceProvider) {
+        const tracer = trace.getTracer(super.name, VERSION);
+
+        return async function tracedHandler(event, lambdaContext, callback) {
+            const spanName = lambdaContext.functionName || 'Lambda Function';
+            const span = tracer.startSpan(spanName, {
+                kind: SpanKind.SERVER,
+                attributes: {
+                    [SemanticAttributes.FAAS_EXECUTION]: lambdaContext.awsRequestId,
+                    [SemanticResourceAttributes.FAAS_ID]: lambdaContext.invokedFunctionArn,
+                },
+            });
+
+            // @ts-ignore
+            if (config.requestHook) {
+                // @ts-ignore
+                config.requestHook(span, {event, context: lambdaContext});
+            }
+
+            return otelContext.with(trace.setSpan(otelContext.active(), span), async () => {
+                try {
+                    // Execute the original handler function
+                    const result = await handler(event, lambdaContext, callback);
+
+                    // @ts-ignore
+                    if (config.responseHook) {
+                        // @ts-ignore
+                        config.responseHook(span, {err: null, res: result});
+                    }
+
+                    span.end();
+                    await traceProvider.forceFlush()
+
+                    return result;
+                } catch (error) {
+                    // @ts-ignore
+                    if (config.responseHook) {
+                        // @ts-ignore
+                        config.responseHook(span, {err: error});
+                    }
+
+                    span.recordException(error);
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: error.message,
+                    });
+                    span.end();
+                    await traceProvider.forceFlush()
+                    throw error; // Rethrow the error to ensure Lambda can handle it accordingly
+                }
+            });
+        };
+    }
+}

src/instrumentation/LambdaInstrumentationWrapper.ts

@@ -49,6 +49,9 @@ export function LambdaRequestHook(span, {event, context}){
 }
 
 export function LambdaResponseHook(span, {err, res}) : void {
+    if(err && !res){
+        return
+    }
     let statusCode = res['statusCode']
     let responseHeaders = res['headers']
     let responseBody = res['body']

test/instrumentation/HapiTest.ts

@@ -138,7 +138,6 @@ if(isCompatible("12.0.0") === true){
             let serverSpanAttributes = spans[1].attributes
             expect(serverSpanAttributes['http.request.header.content-type']).to.equal('application/json')
             expect(serverSpanAttributes['http.request.header.host']).to.equal('localhost:8000')
-            expect(serverSpanAttributes['http.request.header.connection']).to.equal('close')
 
             expect(serverSpanAttributes['http.response.header.content-type']).to.equal('application/json; charset=utf-8')
             expect(serverSpanAttributes['http.response.header.x-test-header']).to.equal('some-value')

test/instrumentation/LambdaInstrumentationWrapperTest.ts

@@ -1,83 +1,95 @@
 import {AgentForTest} from "./AgentForTest";
 import {expect} from "chai";
 import {LambdaRequestHook, LambdaResponseHook} from "../../src/instrumentation/LambdaInstrumentationWrapper";
+import {error} from "loglevel";
 const agentTestWrapper = AgentForTest.getInstance();
 agentTestWrapper.instrument()
 
-describe('Lambda test', () => {
-    let apiGatewayEventV1 = {
-        // "version": "1.0", version isn't always present so cant be relied on
-        "resource": "/my/path",
-        "path": "/my/path",
-        "httpMethod": "PUT",
-        "headers": {
-            "header1": "value1",
-            "header2": "value2",
-            'x-forwarded-proto': 'https',
-            'content-type': 'application/json',
-        },
-        "queryStringParameters": {
-            "parameter1": "value1",
-            "parameter2": "value"
+let apiGatewayEventV1 = {
+    // "version": "1.0", version isn't always present so cant be relied on
+    "resource": "/my/path",
+    "path": "/my/path",
+    "httpMethod": "PUT",
+    "headers": {
+        "header1": "value1",
+        "header2": "value2",
+        'x-forwarded-proto': 'https',
+        'content-type': 'application/json',
+    },
+    "queryStringParameters": {
+        "parameter1": "value1",
+        "parameter2": "value"
+    },
+    "multiValueQueryStringParameters": {
+        "parameter1": [
+            "value1",
+            "value2"
+        ],
+        "parameter2": [
+            "value"
+        ]
+    },
+    "requestContext": {
+        "accountId": "123456789012",
+        "apiId": "id",
+        "authorizer": {
+            "claims": null,
+            "scopes": null
         },
-        "multiValueQueryStringParameters": {
-            "parameter1": [
-                "value1",
-                "value2"
-            ],
-            "parameter2": [
-                "value"
-            ]
-        },
-        "requestContext": {
-            "accountId": "123456789012",
-            "apiId": "id",
-            "authorizer": {
-                "claims": null,
-                "scopes": null
-            },
-            "domainName": "id.execute-api.us-east-1.amazonaws.com",
-            "domainPrefix": "id",
-            "extendedRequestId": "request-id",
-            "httpMethod": "GET",
-            "identity": {
-                "accessKey": null,
-                "accountId": null,
-                "caller": null,
-                "cognitoAuthenticationProvider": null,
-                "cognitoAuthenticationType": null,
-                "cognitoIdentityId": null,
-                "cognitoIdentityPoolId": null,
-                "principalOrgId": null,
-                "sourceIp": "192.0.2.1",
-                "user": null,
-                "userAgent": "user-agent",
-                "userArn": null,
-                "clientCert": {
-                    "clientCertPem": "CERT_CONTENT",
-                    "subjectDN": "www.example.com",
-                    "issuerDN": "Example issuer",
-                    "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
-                    "validity": {
-                        "notBefore": "May 28 12:30:02 2019 GMT",
-                        "notAfter": "Aug  5 09:36:04 2021 GMT"
-                    }
+        "domainName": "id.execute-api.us-east-1.amazonaws.com",
+        "domainPrefix": "id",
+        "extendedRequestId": "request-id",
+        "httpMethod": "GET",
+        "identity": {
+            "accessKey": null,
+            "accountId": null,
+            "caller": null,
+            "cognitoAuthenticationProvider": null,
+            "cognitoAuthenticationType": null,
+            "cognitoIdentityId": null,
+            "cognitoIdentityPoolId": null,
+            "principalOrgId": null,
+            "sourceIp": "192.0.2.1",
+            "user": null,
+            "userAgent": "user-agent",
+            "userArn": null,
+            "clientCert": {
+                "clientCertPem": "CERT_CONTENT",
+                "subjectDN": "www.example.com",
+                "issuerDN": "Example issuer",
+                "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
+                "validity": {
+                    "notBefore": "May 28 12:30:02 2019 GMT",
+                    "notAfter": "Aug  5 09:36:04 2021 GMT"
                 }
-            },
-            "path": "/my/path",
-            "protocol": "HTTP/1.1",
-            "requestId": "id=",
-            "requestTime": "04/Mar/2020:19:15:17 +0000",
-            "requestTimeEpoch": 1583349317135,
-            "resourceId": null,
-            "resourcePath": "/my/path",
-            "stage": "$default"
+            }
         },
-        "pathParameters": null,
-        "stageVariables": null,
-        "body": '{\n\t"req-body": "some-data"\n}',
-        "isBase64Encoded": false
-    }
+        "path": "/my/path",
+        "protocol": "HTTP/1.1",
+        "requestId": "id=",
+        "requestTime": "04/Mar/2020:19:15:17 +0000",
+        "requestTimeEpoch": 1583349317135,
+        "resourceId": null,
+        "resourcePath": "/my/path",
+        "stage": "$default"
+    },
+    "pathParameters": null,
+    "stageVariables": null,
+    "body": '{\n\t"req-body": "some-data"\n}',
+    "isBase64Encoded": false
+}
+
+let response = {
+    "statusCode": "200",
+    "headers": {
+        "a-Header": "some_VALUE",
+        "Content-Type": "application/json"
+    },
+    "body": JSON.stringify({"some_body_data": "response-data"})
+}
+
+
+describe('Lambda test', () => {
 
     let apiGatewayEventV2 = {
         // "version": "2.0", version isn't always present so cant be relied on
@@ -114,14 +126,6 @@ describe('Lambda test', () => {
         body: '{\n\t"req-body": "some-data"\n}',
         isBase64Encoded: false
     }
-    let response = {
-        "statusCode": "200",
-        "headers": {
-            "a-Header": "some_VALUE",
-            "Content-Type": "application/json"
-        },
-        "body": JSON.stringify({"some_body_data": "response-data"})
-    }
 
     beforeEach(() => {
         agentTestWrapper.stop()
@@ -200,3 +204,63 @@ describe('Lambda test', () => {
         expect(lambdaSpan.attributes['http.response.body']).to.equal('{"some_body_data":"response-data"}')
     })
 })
+
+describe("manually instrument lambda function", () => {
+    beforeEach(() => {
+        agentTestWrapper.stop()
+    })
+
+    afterEach( ()=> {
+        agentTestWrapper.stop()
+    })
+    it('can be manually instrumented', async () => {
+        async function myHandler(event, context, callback){
+            return response
+        }
+
+        let wrappedHandler = agentTestWrapper.instrumentLambda(myHandler)
+        await wrappedHandler(apiGatewayEventV1, {}, () => {})
+
+        let spans = agentTestWrapper.getSpans()
+        expect(spans.length).to.equal(1)
+        let lambdaSpan = spans[0]
+        expect(lambdaSpan.attributes['http.method']).to.equal('PUT')
+        expect(lambdaSpan.attributes['http.scheme']).to.equal('https')
+        expect(lambdaSpan.attributes['http.host']).to.equal('id.execute-api.us-east-1.amazonaws.com')
+        expect(lambdaSpan.attributes['http.target']).to.equal('/my/path')
+        expect(lambdaSpan.attributes['http.request.header.content-type']).to.equal('application/json')
+        expect(lambdaSpan.attributes['http.request.header.header1']).to.equal('value1')
+        expect(lambdaSpan.attributes['http.request.body']).to.equal('{\n' +
+            '\t"req-body": "some-data"\n' +
+            '}')
+        expect(lambdaSpan.attributes['http.status_code']).to.equal('200')
+        expect(lambdaSpan.attributes['http.response.header.a-header']).to.equal('some_VALUE')
+        expect(lambdaSpan.attributes['http.response.header.content-type']).to.equal('application/json')
+        expect(lambdaSpan.attributes['http.response.body']).to.equal('{"some_body_data":"response-data"}')
+    })
+
+    it('can be manually instrumented and handle error', async () => {
+        async function myHandler(event, context, callback){
+            throw new Error("some error")
+        }
+
+        let wrappedHandler = agentTestWrapper.instrumentLambda(myHandler)
+        try {
+            await wrappedHandler(apiGatewayEventV1, {}, () => {})
+        } catch(_){}
+
+
+        let spans = agentTestWrapper.getSpans()
+        expect(spans.length).to.equal(1)
+        let lambdaSpan = spans[0]
+        expect(lambdaSpan.attributes['http.method']).to.equal('PUT')
+        expect(lambdaSpan.attributes['http.scheme']).to.equal('https')
+        expect(lambdaSpan.attributes['http.host']).to.equal('id.execute-api.us-east-1.amazonaws.com')
+        expect(lambdaSpan.attributes['http.target']).to.equal('/my/path')
+        expect(lambdaSpan.attributes['http.request.header.content-type']).to.equal('application/json')
+        expect(lambdaSpan.attributes['http.request.header.header1']).to.equal('value1')
+        expect(lambdaSpan.attributes['http.request.body']).to.equal('{\n' +
+            '\t"req-body": "some-data"\n' +
+            '}')
+    })
+})