@newrelic/security-agent 0.7.0 → 1.1.0

package/lib/instrumentation-security/hooks/grpc-js/nr-grpc.js

@@ -0,0 +1,284 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: New Relic Pre-Release
+ */
+
+
+const requestManager = require("../../core/request-manager");
+const secUtils = require("../../core/sec-utils");
+const API = require("../../../nr-security-api");
+const securityMetaData = require('../../core/security-metadata');
+const { EVENT_TYPE, EVENT_CATEGORY } = require('../../core/event-constants');
+const { NR_CSEC_FUZZ_REQUEST_ID } = require('../../core/constants');
+const logger = API.getLogger();
+const semver = require('semver');
+const grpcutils = require('../../core/grpc-utils');
+let serverAddress;
+
+
+module.exports.initialize = function initialize(shim, grpc, moduleName) {
+  logger.info('Instrumenting grpc', moduleName);
+  const grpcVersion = shim.require('./package.json').version;
+  logger.debug("grpc version:", grpcVersion);
+
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    logger.warn('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
+  if (semver.gte(grpcVersion, '1.8.0')) {
+    const resolvingCall = shim.require('./build/src/resolving-call')
+    shim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+  } else {
+    const callStream = shim.require('./build/src/call-stream')
+    shim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+  }
+
+
+  const server = shim.require('./build/src/server')
+  shim.wrap(server.Server.prototype, 'bindAsync', bindAsyncWrapper)
+  shim.wrap(server.Server.prototype, 'register', wrapRegister)
+
+  //get all service
+  shim.wrap(server.Server.prototype, 'addService', wrapAddService);
+
+  //laod package def
+  const makeClient = shim.require('./build/src/make-client');
+  shim.wrap(makeClient, 'loadPackageDefinition', wrapLoadPackageDefinition);
+
+}
+
+
+module.exports.wrapStartResolve = function wrappedStartResolve(shim, resolvingCall) {
+  shim.wrap(resolvingCall.ResolvingCall.prototype, 'start', wrapStart)
+}
+
+module.exports.wrapStartCall = function wrappedClient(shim, callStream) {
+  shim.wrap(callStream.Http2CallStream.prototype, 'start', wrapStart)
+}
+
+module.exports.wrapServer = function wrappedServer(shim, server) {
+  const grpcVersion = shim.require('./package.json').version
+  logger.info("Instrumenting @grpc/grpc-js", grpcVersion)
+  if (semver.lt(grpcVersion, '1.4.0')) {
+    logger.warn('gRPC server-side instrumentation only supported on grpc-js >=1.4.0')
+    return
+  }
+
+  shim.wrap(server.Server.prototype, 'register', wrapRegister)
+  shim.wrap(server.Server.prototype, 'bindAsync', bindAsyncWrapper)
+  //get all service
+  shim.wrap(server.Server.prototype, 'addService', wrapAddService);
+}
+
+module.exports.wrapMakeClient = function wrapMakeClient(shim, makeClient) {
+  shim.wrap(makeClient, 'loadPackageDefinition', wrapLoadPackageDefinition);
+}
+
+
+/**
+ * Instruments grpc-js client by intercepting the function that
+ * initiates client requests. This handles all four types of client
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the generic shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapStart(shim, original) {
+  return function wrappedStart() {
+    const channel = this.channel;
+    const authorityName = (channel.target && channel.target.path) || channel.getDefaultAuthority;
+    // in 1.8.0 this changed from methodName to method
+    const method = this.methodName || this.method;
+    const protocol = 'grpc:';
+    const url = `${protocol}//${authorityName}${method}`;
+    logger.debug("grpc url is:", url)
+    const request = requestManager.getRequest(shim);
+    let urlObj = {
+      "headers":
+      {
+        "host": authorityName
+      },
+      "method": method,
+      "path": method,
+      "protocol": protocol,
+    }
+    if (request) {
+      const traceObject = secUtils.getTraceObject(shim);
+      const secMetadata = securityMetaData.getSecurityMetaData(request, urlObj, traceObject, secUtils.getExecutionId(), EVENT_TYPE.HTTP_REQUEST, EVENT_CATEGORY.HTTP)
+      const secEvent = API.generateSecEvent(secMetadata);
+      API.sendEvent(secEvent);
+    }
+
+    const res = original.apply(this, arguments);
+    return res;
+  }
+}
+
+
+
+function wrapAddService(shim, original) {
+  return function wrappedbindAsync() {
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+function wrapLoadPackageDefinition(shim, original) {
+  return function wrappedbindAsync() {
+    let serviceObject = arguments[0];
+    const result = original.apply(this, arguments);
+    iterateNestedObjectForServiceLookup(result, serviceObject);
+    return result;
+  }
+}
+
+
+
+
+function bindAsyncWrapper(shim, original) {
+  return function wrappedbindAsync() {
+    serverAddress = arguments[0];
+    shim.grpcServerAddress = serverAddress;
+    try {
+      const splittedData = serverAddress.split(":");
+      serverPort = splittedData[1];
+      shim.serverPort = parseInt(serverPort);
+    } catch (error) {
+
+    }
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+
+
+/**
+ * Instruments the grpc-js server by intercepting the moment when
+ * server methods are registered from the method implementations
+ * provided to grpc-js. This handles all four types of server
+ * invocations: unary, client-streaming, server-streaming, and
+ * bidirectional streaming.
+ *
+ * @param {object} shim the web shim to instrument with
+ * @param {Function} original the original function
+ * @returns {Function} the instrumented function
+ */
+function wrapRegister(shim, original) {
+  return function wrappedRegister() {
+    wrapHandler(shim, arguments, '1');
+    const result = original.apply(this, arguments);
+    return result;
+  }
+}
+
+
+/**
+ * Wrapper to hook handler function
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} method 
+ */
+function wrapHandler(shim, mod, method) {
+  shim.wrap(mod, method, function wrapHandler(shim, fn) {
+    return function wrappedHandler() {
+      const type = this.type;
+      const path = this.path;
+      wrapCallback(shim, arguments, '1');
+      addRequestData(shim, type, path, arguments[0]);
+      const result = fn.apply(this, arguments);
+      return result;
+
+    }
+  })
+}
+
+/**
+ * Wrapper to hook callback response
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} method 
+ */
+function wrapCallback(shim, mod, method) {
+  shim.wrap(mod, method, function wrapCallback(shim, fn) {
+    return function wrappedCallback() {
+      const response = arguments[1];
+      const result = fn.apply(this, arguments);
+      return result;
+
+    }
+  })
+}
+
+/**
+ * Utility function to add grpc request data in request map
+ * @param {*} shim 
+ * @param {*} type 
+ * @param {*} path 
+ * @param {*} args 
+ */
+function addRequestData(shim, type, path, args) {
+  const data = Object.assign({});
+  try {
+    const segment = shim.getActiveSegment();
+    if (segment && segment.transaction) {
+      data.method = path;
+      data.url = path;
+      data.uri = path;
+      data.headers = args.metadata.getMap();
+      if (data.headers && data.headers[NR_CSEC_FUZZ_REQUEST_ID]) {
+        let bufferObj = Buffer.from(data.headers[NR_CSEC_FUZZ_REQUEST_ID], "base64");
+        let decodedString = bufferObj.toString("utf8");
+        data.headers[NR_CSEC_FUZZ_REQUEST_ID] = decodedString;
+      }
+      data.type = type;
+      data.protocol = 'grpc';
+      data.isGRPC = true;
+      data.body = JSON.stringify(args.request);
+      data.serverPort = shim.serverPort;
+      const transactionId = segment.transaction.id;
+      requestManager.setRequest(transactionId, data);
+    }
+  } catch (error) {
+    logger.error("Error occured while extracting grpc request", error);
+  }
+}
+
+/**
+ * Utilty to set grpc util Maps
+ * @param {*} serviceObject 
+ */
+function serviceUtil(serviceObject) {
+  let serviceValues = Object.values(serviceObject)[0];
+  for (const [key, value] of Object.entries(serviceValues)) {
+    let servObj = {
+      'serviceName': serviceObject.serviceName,
+      'originalName': value.originalName,
+    }
+    grpcutils.setMethod(value.path, servObj);
+  }
+}
+
+function iterateNestedObjectForServiceLookup(result, serviceObject) {
+  try {
+    for (const key in result) {
+      if (typeof result[key] === 'object' && result[key] !== 'null') {
+        iterateNestedObjectForServiceLookup(result[key], serviceObject); // Recurse into nested object
+      } else {
+        let value = result[key];
+        if (value && value.serviceName) {
+          if (!value.type && value.serviceName) {
+            grpcutils.setService(value.serviceName, serviceObject);
+            serviceUtil(value);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("Error while getting service definition", error);
+  }
+  
+}

package/lib/instrumentation-security/hooks/hapi/nr-hapi.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/http/nr-http.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize

package/lib/instrumentation-security/hooks/koa/@koa/nr-@koa-router.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize

package/lib/instrumentation-security/hooks/ldap/nr-ldap.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize

package/lib/instrumentation-security/hooks/mongodb/common.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 "use strict";

package/lib/instrumentation-security/hooks/mongodb/constants.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/mongodb/nr-mongodb.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 "use strict";

package/lib/instrumentation-security/hooks/mongodb/v2-mongo.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/mongodb/v3-mongo.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/mongodb/v4-mongo.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/mysql/nr-mysql.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 const requestManager = require("../../core/request-manager");

package/lib/instrumentation-security/hooks/native/nr-childProcess.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize;

package/lib/instrumentation-security/hooks/postgres/nr-postgres.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 

package/lib/instrumentation-security/hooks/require/nr-require.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 const requestManager = require('../../core/request-manager');

package/lib/instrumentation-security/hooks/restify/nr-restify.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize

package/lib/instrumentation-security/hooks/undici/nr-undici.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2023 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: New Relic Pre-Release
+ */
+
+module.exports = initialize
+const requestManager = require('../../core/request-manager');
+const secUtils = require("../../core/sec-utils");
+const API = require("../../../nr-security-api");
+const lodash = require('lodash');
+const securityMetaData = require('../../core/security-metadata');
+const { EVENT_TYPE, EVENT_CATEGORY } = require('../../core/event-constants');
+const { NR_CSEC_FUZZ_REQUEST_ID, QUESTION_MARK, EMPTY_STRING, COLON, SLASH } = require('../../core/constants');
+const NRCSECTRACINGDATA = 'NR-CSEC-TRACING-DATA';
+const DOUBLE_SLASH = '//';
+const logger = API.getLogger();
+const url = require('url');
+
+
+/**
+ * Entry point undici module instrumentation.
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} moduleName 
+ */
+function initialize(shim, mod, moduleName) {
+  logger.info('Instrumenting ' + moduleName);
+  fetchHook(shim, mod, "fetch");
+  let util = shim.require('./lib/core/util');
+  parseOriginHook(shim, util, "parseOrigin")
+
+}
+/**
+ * Wrapper for util.parseOrigin
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} methodName 
+ */
+function parseOriginHook(shim, mod, methodName) {
+  shim.wrap(mod, methodName, function ClientWrapper(shim, fn) {
+    logger.debug(`Instrumenting ${methodName}`);
+    if (!shim.isFunction(fn)) {
+      return fn
+    }
+    return function wrapper() {
+      const request = requestManager.getRequest(shim);
+      try {
+        if (typeof arguments[0] === 'string') {
+          let URLObject = new URL(arguments[0]);
+          const data = {};
+          data.headers = {};
+          data.path = URLObject.pathname ? URLObject.pathname : EMPTY_STRING;
+          data.protocol = URLObject.protocol ? URLObject.protocol : 'http:';
+          data.headers.host = URLObject.host ? URLObject.host : URLObject.hostname;
+          shim.interceptedArgs = data;
+          if (request) {
+            const traceObject = secUtils.getTraceObject(shim);
+            const secMetadata = securityMetaData.getSecurityMetaData(request, data, traceObject, secUtils.getExecutionId(), EVENT_TYPE.HTTP_REQUEST, EVENT_CATEGORY.HTTP)
+            this.secEvent = API.generateSecEvent(secMetadata);
+            API.sendEvent(this.secEvent);
+          }
+        }
+      } catch (error) {
+
+      }
+      const result = fn.apply(this, arguments);
+      if (result && request && request.headers[NR_CSEC_FUZZ_REQUEST_ID]) {
+        API.generateExitEvent(this.secEvent);
+        delete this.secEvent
+      }
+      return result;
+    }
+  })
+}
+
+/**
+ * Wrapper to hook undici.fetch()
+ * @param {*} shim 
+ * @param {*} mod 
+ * @param {*} methodName 
+ */
+function fetchHook(shim, mod, methodName) {
+  shim.wrap(mod, methodName, function makeWrapper(shim, fn) {
+    logger.debug(`Instrumenting ${methodName}`);
+    if (!shim.isFunction(fn)) {
+      return fn
+    }
+    return function wrapper() {
+      const request = requestManager.getRequest(shim);
+      try {
+        const completeURL = arguments[0];
+        const parsedUrl = url.parse(completeURL);
+        const data = {};
+        data.headers = {};
+        data.method = arguments[0].method ? arguments[0].method : EMPTY_STRING;
+        data.path = parsedUrl.pathname ? parsedUrl.pathname : parsedUrl.path;
+        data.protocol = parsedUrl.protocol;
+        data.headers.host = parsedUrl.host ? parsedUrl.host : parsedUrl.hostname;
+        data.port = parsedUrl.port ? parsedUrl.port : parsedUrl.port;
+
+        shim.interceptedArgs = data;
+        if (request && !lodash.isEmpty(data.headers.host) && !lodash.isEmpty(data.path)) {
+          const appUUID = API.getSecAgent().applicationInfo.applicationUUID;
+          const traceObject = secUtils.getTraceObject(shim);
+          const secMetadata = securityMetaData.getSecurityMetaData(request, data, traceObject, secUtils.getExecutionId(), EVENT_TYPE.HTTP_REQUEST, EVENT_CATEGORY.HTTP)
+          this.secEvent = API.generateSecEvent(secMetadata);
+          API.sendEvent(this.secEvent);
+
+          let traceHeader = EMPTY_STRING;
+          if (request.headers['nr-csec-tracing-data']) {
+            traceHeader = request.headers['nr-csec-tracing-data'];
+          }
+
+          if (arguments[1] instanceof Object) {
+            if (arguments[1] && arguments[1].headers && request.headers) {
+              arguments[1].headers[NRCSECTRACINGDATA] = traceHeader + appUUID + '/' + this.secEvent.apiId + '/' + this.secEvent.id + ';';
+            } else {
+              arguments[1].headers = {};
+              arguments[1].headers[NRCSECTRACINGDATA] = traceHeader + appUUID + '/' + this.secEvent.apiId + '/' + this.secEvent.id + ';';
+            }
+            if (request && request.headers[NR_CSEC_FUZZ_REQUEST_ID] && arguments[1].headers) {
+              arguments[1].headers[NR_CSEC_FUZZ_REQUEST_ID] = request.headers[NR_CSEC_FUZZ_REQUEST_ID];
+            }
+          }
+        }
+      } catch (error) {
+        logger.debug("Error while extracting undici fetch args:", error);
+      }
+      const result = fn.apply(this, arguments);
+
+      if (result && request && request.headers[NR_CSEC_FUZZ_REQUEST_ID]) {
+        API.generateExitEvent(this.secEvent);
+        delete this.secEvent
+      }
+      return result;
+    }
+  })
+}
+

package/lib/instrumentation-security/hooks/xpath/nr-xpath.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 module.exports = initialize

package/lib/instrumentation-security/index.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 const API = require('../nr-security-api');
@@ -190,9 +190,65 @@ newrelic.instrumentWebframework({
   }
 })
 
+newrelic.instrumentWebframework({
+  moduleName: 'undici',
+  isEsm: true,
+  onRequire: require('./hooks/undici/nr-undici'),
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
+
 
+newrelic.instrument({
+  type: 'conglomerate',
+  moduleName: '@grpc/grpc-js/build/src/server',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapServer,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
+newrelic.instrument({
+  type: 'conglomerate',
+  moduleName: '@grpc/grpc-js/build/src/make-client',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapMakeClient,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
+newrelic.instrument({
+  type: 'conglomerate',
+  moduleName: '@grpc/grpc-js/build/src/resolving-call',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapStartResolve,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
+
+newrelic.instrument({
+  type: 'conglomerate',
+  moduleName: '@grpc/grpc-js/build/src/call-stream',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').wrapStartCall,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
+
+newrelic.instrument({
+  type: 'conglomerate',
+  moduleName: '@grpc/grpc-js',
+  isEsm: true,
+  onRequire: require('./hooks/grpc-js/nr-grpc').initialize,
+  onError: function intrumentErrorHandler(err) {
+    logger.error(err.message, err.stack)
+  }
+})
 
 
 

package/lib/nr-security-agent/index.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 const API = require('../nr-security-api');
 const NRAgent = API.getNRAgent();

package/lib/nr-security-agent/lib/core/Auth-headers.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 const API = require('../../../nr-security-api');

package/lib/nr-security-agent/lib/core/ContainerProperties.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 let containerProperties = undefined;

package/lib/nr-security-agent/lib/core/ECSProperties.js

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: New Relic Pre-Release
+ * SPDX-License-Identifier: New Relic Software License v1.0
  */
 
 let ecsProperties;