refactor: added options pattern for backend connector init (#1592)

kirrg001 · aryamohanan · commit 3cacf86e196b · 2025-03-03T09:21:38.000+05:30
refs #1315
diff --git a/packages/aws-fargate/src/activate.js b/packages/aws-fargate/src/activate.js
@@ -54,7 +54,15 @@ function init() {
       }
 
       identityProvider.init(taskArn, containerId);
-      backendConnector.init(config, identityProvider, false, true, 950);
+
+      backendConnector.init({
+        config,
+        identityProvider,
+        stopSendingOnFailure: false,
+        propagateErrorsUpstream: true,
+        defaultTimeout: 950
+      });
+
       instanaCore.init(config, backendConnector, identityProvider);
       metrics.activate(backendConnector);
       tracing.activate();
diff --git a/packages/aws-lambda/src/wrapper.js b/packages/aws-lambda/src/wrapper.js
@@ -259,7 +259,15 @@ function init(event, arnInfo, _config) {
   }
 
   identityProvider.init(arnInfo);
-  backendConnector.init(config, identityProvider, true, false, 500, useLambdaExtension);
+
+  backendConnector.init({
+    config,
+    identityProvider,
+    stopSendingOnFailure: true,
+    propagateErrorsUpstream: false,
+    defaultTimeout: 500,
+    useLambdaExtension
+  });
 
   // instanaCore.init also normalizes the config as a side effect
   instanaCore.init(config, backendConnector, identityProvider);
diff --git a/packages/azure-container-services/src/activate.js b/packages/azure-container-services/src/activate.js
@@ -32,7 +32,15 @@ function init() {
 
   try {
     identityProvider.init();
-    backendConnector.init(config, identityProvider, false, true, 950);
+
+    backendConnector.init({
+      config,
+      identityProvider,
+      stopSendingOnFailure: false,
+      propagateErrorsUpstream: true,
+      defaultTimeout: 950
+    });
+
     instanaCore.init(config, backendConnector, identityProvider);
     tracing.activate();
 
diff --git a/packages/google-cloud-run/src/activate.js b/packages/google-cloud-run/src/activate.js
@@ -51,7 +51,15 @@ function init() {
 
     try {
       identityProvider.init(containerInstanceId);
-      backendConnector.init(config, identityProvider, false, true, 950);
+
+      backendConnector.init({
+        config,
+        identityProvider,
+        stopSendingOnFailure: false,
+        propagateErrorsUpstream: true,
+        defaultTimeout: 950
+      });
+
       instanaCore.init(config, backendConnector, identityProvider);
       metrics.activate(backendConnector);
       tracing.activate();
diff --git a/packages/opentelemetry-exporter/src/index.js b/packages/opentelemetry-exporter/src/index.js
@@ -96,7 +96,7 @@ class InstanaExporter {
     instanaEnvironment.validate();
 
     if (instanaEnvironment.isValid()) {
-      instanaBackendConnector.init({ logger }, null, null, true);
+      instanaBackendConnector.init({ config: { logger }, stopSendingOnFailure: false, propagateErrorsUpstream: true });
       this._isShutdown = false;
     }
   }
diff --git a/packages/serverless-collector/src/activate.js b/packages/serverless-collector/src/activate.js
@@ -31,7 +31,15 @@ async function init() {
     }
 
     identityProvider.init();
-    backendConnector.init(config, identityProvider, false, true, 950);
+
+    backendConnector.init({
+      config,
+      identityProvider,
+      stopSendingOnFailure: false,
+      propagateErrorsUpstream: true,
+      defaultTimeout: 950
+    });
+
     instanaCore.init(config, backendConnector, identityProvider);
     tracing.activate();
 
diff --git a/packages/serverless/src/backend_connector.js b/packages/serverless/src/backend_connector.js
@@ -16,37 +16,38 @@ const layerExtensionHostname = 'localhost';
 const layerExtensionPort = process.env.INSTANA_LAYER_EXTENSION_PORT
   ? Number(process.env.INSTANA_LAYER_EXTENSION_PORT)
   : 7365;
-let useLambdaExtension = false;
 
 const timeoutEnvVar = 'INSTANA_TIMEOUT';
-let defaultTimeout = 500;
 const layerExtensionTimeout = process.env.INSTANA_LAMBDA_EXTENSION_TIMEOUT_IN_MS
   ? Number(process.env.INSTANA_LAMBDA_EXTENSION_TIMEOUT_IN_MS)
   : 500;
-let backendTimeout = defaultTimeout;
 
 const proxyEnvVar = 'INSTANA_ENDPOINT_PROXY';
 let proxyAgent;
 
-let stopSendingOnFailure = true;
-let propagateErrorsUpstream = false;
+const disableCaCheckEnvVar = 'INSTANA_DISABLE_CA_CHECK';
+const disableCaCheck = process.env[disableCaCheckEnvVar] === 'true';
+
 let requestHasFailed = false;
 let warningsHaveBeenLogged = false;
 
-const disableCaCheckEnvVar = 'INSTANA_DISABLE_CA_CHECK';
-const disableCaCheck = process.env[disableCaCheckEnvVar] === 'true';
+const defaults = {
+  config: {},
+  identityProvider: null,
+  stopSendingOnFailure: true,
+  propagateErrorsUpstream: false,
+  defaultTimeout: 500,
+  backendTimeout: 500,
+  useLambdaExtension: false
+};
 
+let options;
 let hostHeader;
 
-exports.init = function init(
-  config,
-  identityProvider,
-  _stopSendingOnFailure,
-  _propagateErrorsUpstream,
-  _defaultTimeout,
-  _useLambdaExtension
-) {
-  logger = config.logger;
+exports.init = function init(opts) {
+  options = Object.assign(defaults, opts);
+
+  logger = options.config.logger;
 
   if (process.env[proxyEnvVar] && !environmentUtil.sendUnencrypted) {
     const proxyUrl = process.env[proxyEnvVar];
@@ -65,39 +66,33 @@ exports.init = function init(
     );
   }
 
-  stopSendingOnFailure = _stopSendingOnFailure == null ? true : _stopSendingOnFailure;
-  propagateErrorsUpstream = _propagateErrorsUpstream == null ? false : _propagateErrorsUpstream;
-  defaultTimeout = _defaultTimeout == null ? defaultTimeout : _defaultTimeout;
-  useLambdaExtension = _useLambdaExtension;
-  backendTimeout = defaultTimeout;
-
   if (process.env[timeoutEnvVar]) {
-    backendTimeout = parseInt(process.env[timeoutEnvVar], 10);
-    if (isNaN(backendTimeout) || backendTimeout < 0) {
+    options.backendTimeout = parseInt(process.env[timeoutEnvVar], 10);
+
+    if (isNaN(options.backendTimeout) || options.backendTimeout < 0) {
       logger.warn(
         `The value of ${timeoutEnvVar} (${process.env[timeoutEnvVar]}) cannot be parsed to a valid numerical value. ` +
-          `Will fall back to the default timeout (${defaultTimeout} ms).`
+          `Will fall back to the default timeout (${options.defaultTimeout} ms).`
       );
-      backendTimeout = defaultTimeout;
+
+      options.backendTimeout = 500;
     }
   }
 
-  if (identityProvider) {
-    hostHeader = identityProvider.getHostHeader();
+  if (options.identityProvider) {
+    hostHeader = options.identityProvider.getHostHeader();
     if (hostHeader == null) {
       hostHeader = 'nodejs-serverless';
     }
   } else {
     hostHeader = 'nodejs-serverless';
   }
 
-  requestHasFailed = false;
-
   // Heartbeat is only for the AWS Lambda extension
   // IMPORTANT: the @instana/aws-lambda package will not
   //            send data once. It can happen all the time till the Lambda handler dies!
   //            SpanBuffer sends data asap and when the handler is finished the rest is sent.
-  if (useLambdaExtension) {
+  if (options.useLambdaExtension) {
     scheduleLambdaExtensionHeartbeatRequest();
   }
 };
@@ -178,7 +173,7 @@ function scheduleLambdaExtensionHeartbeatRequest() {
 
     function handleHeartbeatError(e) {
       // Make sure we do not try to talk to the Lambda extension again.
-      useLambdaExtension = false;
+      options.useLambdaExtension = false;
       clearInterval(heartbeatInterval);
 
       logger.debug(
@@ -231,7 +226,7 @@ function getTransport(localUseLambdaExtension) {
 }
 
 function getBackendTimeout(localUseLambdaExtension) {
-  return localUseLambdaExtension ? layerExtensionTimeout : backendTimeout;
+  return localUseLambdaExtension ? layerExtensionTimeout : options.backendTimeout;
 }
 
 function send(resourcePath, payload, finalLambdaRequest, callback) {
@@ -245,9 +240,9 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
   // We need a local copy of the global useLambdaExtension variable, otherwise it might be changed concurrently by
   // scheduleLambdaExtensionHeartbeatRequest. But we need to remember the value at the time we _started_ the request to
   // decide whether to fall back to sending to the back end directly or give up sending data completely.
-  let localUseLambdaExtension = useLambdaExtension;
+  let localUseLambdaExtension = options.useLambdaExtension;
 
-  if (requestHasFailed && stopSendingOnFailure) {
+  if (requestHasFailed && options.stopSendingOnFailure) {
     logger.info(
       `Not attempting to send data to ${resourcePath} as a previous request has already timed out or failed.`
     );
@@ -286,7 +281,7 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
   // serialize the payload object
   const serializedPayload = JSON.stringify(payload);
 
-  const options = {
+  const reqOptions = {
     hostname: localUseLambdaExtension ? layerExtensionHostname : environmentUtil.getBackendHost(),
     port: localUseLambdaExtension ? layerExtensionPort : environmentUtil.getBackendPort(),
     path: requestPath,
@@ -300,10 +295,10 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
     rejectUnauthorized: !disableCaCheck
   };
 
-  options.timeout = getBackendTimeout(localUseLambdaExtension);
+  reqOptions.timeout = getBackendTimeout(localUseLambdaExtension);
 
   if (proxyAgent && !localUseLambdaExtension) {
-    options.agent = proxyAgent;
+    reqOptions.agent = proxyAgent;
   }
 
   let req;
@@ -319,7 +314,7 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
     // report metrics and traces quite a bit. The (acceptable) downside is that we do not get to examine the response
     // for HTTP status codes.
 
-    req = transport.request(options);
+    req = transport.request(reqOptions);
   } else {
     // If (a) our Lambda extension is available, or if (b) a user-provided proxy is in use, we do *not* apply the
     // optimization outlined above. Instead, we opt for the more traditional workflow of waiting until the HTTP response
@@ -329,7 +324,7 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
     //
     // See the req.end(serializedPayload) call below, too. In the no-extension/no-proxy case, that call has the callback
     // to end the processing. Otherwise, the callback is provided here to http.request().
-    req = transport.request(options, () => {
+    req = transport.request(reqOptions, () => {
       // When the Node.js process is frozen while the request is pending, and then thawed later,
       // this can trigger a stale, bogus timeout event (because from the perspective of the freshly thawed Node.js
       // runtime, the request has been pending and inactive since a long time). To avoid that, we remove all listeners
@@ -383,7 +378,7 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
       );
 
       // Make sure we do not try to talk to the Lambda extension again.
-      useLambdaExtension = localUseLambdaExtension = false;
+      options.useLambdaExtension = localUseLambdaExtension = false;
       clearInterval(heartbeatInterval);
 
       // Retry the request immediately, this time sending it to serverless-acceptor directly.
@@ -394,7 +389,7 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
       // (or a user-provided proxy).
       requestHasFailed = true;
 
-      if (!propagateErrorsUpstream) {
+      if (!options.propagateErrorsUpstream) {
         if (proxyAgent) {
           logger.warn(
             'Could not send traces and metrics to Instana. Could not connect to the configured proxy ' +
@@ -409,14 +404,14 @@ function send(resourcePath, payload, finalLambdaRequest, callback) {
         }
       }
 
-      handleCallback(propagateErrorsUpstream ? e : undefined);
+      handleCallback(options.propagateErrorsUpstream ? e : undefined);
     }
   });
 
   req.on('finish', () => {
     logger.debug(`Sent data to Instana (${requestPath}).`);
 
-    if (useLambdaExtension && finalLambdaRequest) {
+    if (options.useLambdaExtension && finalLambdaRequest) {
       clearInterval(heartbeatInterval);
     }
   });
@@ -465,7 +460,7 @@ function onTimeout(localUseLambdaExtension, req, resourcePath, payload, finalLam
     );
 
     // Make sure we do not try to talk to the Lambda extension again.
-    useLambdaExtension = localUseLambdaExtension = false;
+    options.useLambdaExtension = localUseLambdaExtension = false;
     clearInterval(heartbeatInterval);
 
     if (req && !req.destroyed) {
@@ -498,14 +493,16 @@ function onTimeout(localUseLambdaExtension, req, resourcePath, payload, finalLam
     }
 
     const message =
-      'Could not send traces and metrics to Instana. The Instana back end did not respond in the configured timeout ' +
-      `of ${backendTimeout} ms. The timeout can be configured by setting the environment variable ${timeoutEnvVar}.`;
+      'Could not send traces and metrics to Instana. The Instana back end did not respond ' +
+      'in the configured timeout ' +
+      `of ${options.backendTimeout} ms. The timeout can be configured by ` +
+      `setting the environment variable ${timeoutEnvVar}.`;
 
-    if (!propagateErrorsUpstream) {
+    if (!options.propagateErrorsUpstream) {
       logger.warn(message);
     }
 
-    handleCallback(propagateErrorsUpstream ? new Error(message) : undefined);
+    handleCallback(options.propagateErrorsUpstream ? new Error(message) : undefined);
   }
 }
 
diff --git a/packages/serverless/test/backend_connector_test.js b/packages/serverless/test/backend_connector_test.js
@@ -63,7 +63,7 @@ describe('[UNIT] backend connector', () => {
     });
 
     it('when lambda extension is not used', async () => {
-      backendConnector.init(config);
+      backendConnector.init({ config });
 
       expect(uninstrumentedHttp.http.request.called).to.be.false;
       await delay(750);
@@ -75,7 +75,7 @@ describe('[UNIT] backend connector', () => {
     it('when lambda extension is used & heartbeat is not working', async () => {
       expect(global.clearInterval.called).to.be.false;
 
-      backendConnector.init(config, null, null, null, null, true);
+      backendConnector.init({ config, useLambdaExtension: true });
 
       expect(uninstrumentedHttp.http.request.called).to.be.true;
       expect(uninstrumentedHttp.http.request.callCount).to.eql(1);
@@ -89,7 +89,7 @@ describe('[UNIT] backend connector', () => {
     it('when lambda extension is used & heartbeat is working, but timeout when talking to extension', async () => {
       expect(global.clearInterval.called).to.be.false;
 
-      backendConnector.init(config, null, null, null, null, true);
+      backendConnector.init({ config, stopSendingOnFailure: false, useLambdaExtension: true });
 
       expect(uninstrumentedHttp.http.request.called).to.be.true;
       expect(uninstrumentedHttp.http.request.callCount).to.eql(1);
@@ -118,7 +118,7 @@ describe('[UNIT] backend connector', () => {
     it('when lambda extension is used & heartbeat is working, but error when talking to extension', async () => {
       expect(global.clearInterval.called).to.be.false;
 
-      backendConnector.init(config, null, null, null, null, true);
+      backendConnector.init({ config, useLambdaExtension: true });
 
       expect(uninstrumentedHttp.http.request.called).to.be.true;
       expect(uninstrumentedHttp.http.request.callCount).to.eql(1);
@@ -143,7 +143,7 @@ describe('[UNIT] backend connector', () => {
     });
 
     it('when lambda extension is used & heartbeat is working & send once', async () => {
-      backendConnector.init(config, null, null, null, null, true);
+      backendConnector.init({ config, useLambdaExtension: true });
 
       expect(uninstrumentedHttp.http.request.called).to.be.true;
       expect(uninstrumentedHttp.http.request.callCount).to.eql(1);
@@ -189,7 +189,7 @@ describe('[UNIT] backend connector', () => {
     });
 
     it('when lambda extension is used & heartbeat is working & more data is incoming', async () => {
-      backendConnector.init(config, null, null, null, null, true);
+      backendConnector.init({ config, useLambdaExtension: true });
 
       expect(uninstrumentedHttp.http.request.called).to.be.true;
       expect(uninstrumentedHttp.http.request.callCount).to.eql(1);

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ class InstanaExporter {`
`96`	`96`	`instanaEnvironment.validate();`
`97`	`97`
`98`	`98`	`if (instanaEnvironment.isValid()) {`
`99`		`- instanaBackendConnector.init({ logger }, null, null, true);`
	`99`	`+ instanaBackendConnector.init({ config: { logger }, stopSendingOnFailure: false, propagateErrorsUpstream: true });`
`100`	`100`	`this._isShutdown = false;`
`101`	`101`	`}`
`102`	`102`	`}`