@mhubcloud/tms_core 3.4.0-beta.3 → 3.4.0-beta.5

package/dist/index.js

@@ -47,98 +47,6 @@ __export(broker_exports, {
 });
 var import_cosmos = require("@azure/cosmos");
 var import_service_bus = require("@azure/service-bus");
-var serviceBusConnectionString = process.env.ServiceBusConnectionString;
-var cosmosConnectionString = process.env.CosmosDbConnectionString;
-var cosmosDatabaseName = process.env.CosmosDbDatabaseName;
-var cosmosContainerName = process.env.CosmosEventsContainerName;
-var serviceBusClient;
-var cosmosClient;
-var senders = {};
-function resolveEvent(eventCode, publisherConfig) {
-  if (!publisherConfig) {
-    const envConfig = process.env.Broker_PublisherConfig;
-    publisherConfig = envConfig ? JSON.parse(envConfig) : {};
-  }
-  const publishers = [];
-  for (const publisher2 of Object.keys(publisherConfig)) {
-    const publisherEvents = publisherConfig[publisher2];
-    if (publisherEvents[0] === "*") {
-      let matchesExcluded = false;
-      if (Array.isArray(publisherEvents[1]) && publisherEvents[1].length > 0) {
-        for (const event of publisherEvents[1]) {
-          if (matchesExcluded) {
-            break;
-          }
-          if (typeof event === "string") {
-            const regex = new RegExp(event);
-            matchesExcluded = regex.test(eventCode);
-          }
-        }
-      }
-      if (!matchesExcluded) {
-        publishers.push(publisher2);
-      }
-    } else {
-      let match = false;
-      for (const event of publisherEvents) {
-        if (typeof event === "string") {
-          const regex = new RegExp(event);
-          match = regex.test(eventCode);
-        }
-        if (match) {
-          publishers.push(publisher2);
-        }
-      }
-    }
-  }
-  if (publishers.length === 0) {
-    return null;
-  }
-  return publishers;
-}
-async function dispatchEvent(message, queues) {
-  if (!serviceBusClient) {
-    if (!serviceBusConnectionString) {
-      throw new Error("Service Bus connection string is missing.");
-    }
-    serviceBusClient = new import_service_bus.ServiceBusClient(serviceBusConnectionString);
-  }
-  await Promise.all(
-    queues.map(async (queue) => {
-      try {
-        let sender;
-        if (senders[queue]) {
-          sender = senders[queue];
-        } else {
-          senders[queue] = serviceBusClient.createSender(queue);
-          sender = senders[queue];
-        }
-        await sender.sendMessages({ body: message });
-      } catch (e) {
-        console.log(`Sending to queue ${queue} failed`);
-      }
-    })
-  );
-}
-async function logToCosmosDb(message, logger) {
-  if (!cosmosClient) {
-    if (!cosmosConnectionString) {
-      throw new Error("Cosmos DB connection string is missing.");
-    }
-    cosmosClient = new import_cosmos.CosmosClient(cosmosConnectionString);
-  }
-  if (!cosmosDatabaseName) {
-    throw new Error("Cosmos DB database name is missing.");
-  }
-  if (!cosmosContainerName) {
-    throw new Error("Cosmos DB events container name is missing.");
-  }
-  try {
-    await cosmosClient.database(cosmosDatabaseName).container(cosmosContainerName).items.create(message);
-  } catch (e) {
-    utils_exports.logException(logger, e);
-  }
-}
 
 // src/utils/utils.ts
 var utils_exports = {};
@@ -147,19 +55,19 @@ __export(utils_exports, {
   encodeEmail: () => encodeEmail,
   extractAdCode: () => extractAdCode,
   flatten: () => flatten,
+  formatError: () => formatError,
   handlePlatformRequest: () => handlePlatformRequest,
   handleResponse: () => handleResponse,
   logEvent: () => logEvent,
   logException: () => logException,
   logMessage: () => logMessage,
-  parseErrorMessage: () => parseErrorMessage,
   prepareTestRequestHeaders: () => prepareTestRequestHeaders,
   removeUndefined: () => removeUndefined
 });
 var crypto = __toESM(require("crypto"));
 var appInsights = __toESM(require("applicationinsights"));
 var aiClient = null;
-if (process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || process.env.APPINSIGHTS_INSTRUMENTATIONKEY) {
+if (process.env.APPLICATIONINSIGHTS_CONNECTION_STRING) {
   appInsights.setup().setAutoCollectDependencies(false).setAutoCollectConsole(true, false).setSendLiveMetrics(false).setAutoCollectRequests(false).setAutoCollectPerformance(false).setUseDiskRetryCaching(false).start();
   aiClient = appInsights.defaultClient;
 }
@@ -192,15 +100,17 @@ function logMessage(level, message, properties) {
     properties
   });
 }
-function logEvent(publisher2, event, region) {
+function logEvent(publisher2, event, region, status, payload) {
   const properties = {
     publisher: publisher2,
     event,
-    region
+    region,
+    status,
+    payload
   };
   logMessage(1, "Event dispatched to platform", properties);
 }
-function logException(log2, exception) {
+function logException(exception) {
   aiClient?.trackException({ exception });
 }
 function removeUndefined(originalValue) {
@@ -314,7 +224,10 @@ async function handlePlatformRequest({
     // eslint-disable-next-line @typescript-eslint/naming-convention
     headers: { ...requestOptions.headers }
   };
-  const rawPlatformResponse = await fetch(fullUrl, fetchRequestOptions);
+  const rawPlatformResponse = await fetch(
+    fullUrl,
+    fetchRequestOptions
+  );
   if (process.env.PUBLISHER_TESTURL) {
     await handleTestRequest({
       fetchRequestOptions,
@@ -328,10 +241,22 @@ async function handlePlatformRequest({
       rawPlatformResponse,
       event.event
     );
-    logEvent(source, event.event, event.region);
+    logEvent(
+      source,
+      event.event,
+      event.region,
+      rawPlatformResponse.status,
+      requestOptions.body ? JSON.stringify(requestOptions.body) : void 0
+    );
     return processedPlatformResponse;
   } else {
-    logEvent(source, event.event, event.region);
+    logEvent(
+      source,
+      event.event,
+      event.region,
+      rawPlatformResponse.status,
+      requestOptions.body ? JSON.stringify(requestOptions.body) : void 0
+    );
   }
 }
 async function handleTestRequest(params) {
@@ -354,18 +279,115 @@ async function handleTestRequest(params) {
   } catch {
   }
 }
-function parseErrorMessage(error) {
-  let errorMessage;
+function formatError(error) {
+  let formattedError;
   if (error instanceof Error) {
+    formattedError = error;
     if (error.cause) {
-      errorMessage = `${error.message} Cause: ${error.cause.toString()}`;
+      formattedError.message = `${error.message} Cause: ${error.cause.toString()}`;
     } else {
-      errorMessage = error.message;
+      formattedError.message = error.message;
     }
   } else {
-    errorMessage = error;
+    formattedError = new Error(error);
+  }
+  return formattedError;
+}
+
+// src/broker.ts
+var serviceBusConnectionString = process.env.ServiceBusConnectionString;
+var cosmosConnectionString = process.env.CosmosDbConnectionString;
+var cosmosDatabaseName = process.env.CosmosDbDatabaseName;
+var cosmosContainerName = process.env.CosmosDbEventsContainerName;
+var serviceBusClient;
+var cosmosClient;
+var senders = {};
+function resolveEvent(eventCode, publisherConfig) {
+  if (!publisherConfig) {
+    const envConfig = process.env.Broker_PublisherConfig;
+    publisherConfig = envConfig ? JSON.parse(envConfig) : {};
+  }
+  const publishers = [];
+  for (const publisher2 of Object.keys(publisherConfig)) {
+    const publisherEvents = publisherConfig[publisher2];
+    if (publisherEvents) {
+      if (publisherEvents[0] === "*") {
+        let matchesExcluded = false;
+        if (Array.isArray(publisherEvents[1]) && publisherEvents[1].length > 0) {
+          for (const event of publisherEvents[1]) {
+            if (matchesExcluded) {
+              break;
+            }
+            if (typeof event === "string") {
+              const regex = new RegExp(event);
+              matchesExcluded = regex.test(eventCode);
+            }
+          }
+        }
+        if (!matchesExcluded) {
+          publishers.push(publisher2);
+        }
+      } else {
+        let match = false;
+        for (const event of publisherEvents) {
+          if (typeof event === "string") {
+            const regex = new RegExp(event);
+            match = regex.test(eventCode);
+          }
+          if (match) {
+            publishers.push(publisher2);
+          }
+        }
+      }
+    }
+  }
+  if (publishers.length === 0) {
+    return null;
+  }
+  return publishers;
+}
+async function dispatchEvent(message, queues) {
+  if (!serviceBusClient) {
+    if (!serviceBusConnectionString) {
+      throw new Error("Service Bus connection string is missing.");
+    }
+    serviceBusClient = new import_service_bus.ServiceBusClient(serviceBusConnectionString);
+  }
+  await Promise.all(
+    queues.map(async (queue) => {
+      try {
+        let sender;
+        if (senders[queue]) {
+          sender = senders[queue];
+        } else {
+          senders[queue] = serviceBusClient.createSender(queue);
+          sender = senders[queue];
+        }
+        await sender.sendMessages({ body: message });
+      } catch (e) {
+        console.log(`Sending to queue ${queue} failed`);
+      }
+    })
+  );
+}
+async function logToCosmosDb(message) {
+  if (!cosmosClient) {
+    if (!cosmosConnectionString) {
+      throw new Error("Cosmos DB connection string is missing.");
+    }
+    cosmosClient = new import_cosmos.CosmosClient(cosmosConnectionString);
+  }
+  if (!cosmosDatabaseName) {
+    throw new Error("Cosmos DB database name is missing.");
+  }
+  if (!cosmosContainerName) {
+    throw new Error("Cosmos DB events container name is missing.");
+  }
+  try {
+    await cosmosClient.database(cosmosDatabaseName).container(cosmosContainerName).items.create(message);
+  } catch (e) {
+    logException(e);
   }
-  return errorMessage;
 }
 
 // src/defaultPublisher.ts
@@ -386,15 +408,21 @@ async function defaultPublisher(azureFunctionContext, serviceBusMessage, source,
   for (const result of results) {
     if (result.status === "rejected") {
       if (result.reason instanceof Error) {
-        const errorMessage = parseErrorMessage(result.reason);
-        logException(azureFunctionContext.log, new Error(errorMessage));
-        throw new Error(errorMessage);
+        const formattedError = formatError(result.reason);
+        logException(
+          azureFunctionContext.log,
+          new Error(formattedError.message)
+        );
+        throw formattedError;
       } else {
-        const errorMessage = parseErrorMessage(
+        const formattedError = formatError(
           typeof result.reason === "object" ? JSON.stringify(result.reason) : result.reason
         );
-        logException(azureFunctionContext.log, new Error(errorMessage));
-        throw new Error(errorMessage);
+        logException(
+          azureFunctionContext.log,
+          new Error(formattedError.message)
+        );
+        throw formattedError;
       }
     }
   }
@@ -580,42 +608,9 @@ var facebook = {
   }
 };
 
-// src/utils/tokens/googleAdsToken.ts
-var tokenCache = null;
-var tokenPromise = null;
-async function fetchGoogleAdsToken(config) {
-  if (tokenCache && tokenCache.createdAt + 3500 * 1e3 > Date.now()) {
-    return tokenCache;
-  }
-  if (!tokenPromise) {
-    tokenPromise = (async () => {
-      const tokenResponse = await fetch(`https://oauth2.googleapis.com/token`, {
-        method: "POST",
-        headers: {
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: new URLSearchParams({
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          client_id: config.client.id,
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          client_secret: config.client.secret,
-          refreshToken: config.refreshToken,
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          grant_type: "refresh_token"
-        })
-      });
-      const parsedTokenResponse = await tokenResponse.json();
-      const createdAt = Date.now();
-      tokenCache = { token: parsedTokenResponse.access_token, createdAt };
-      tokenPromise = null;
-      return tokenCache;
-    })();
-  }
-  return tokenPromise;
-}
-
 // src/publishers/googleAds.ts
+var tokenCache;
+var tokenPromise;
 var googleAds = {
   source: "GoogleAds",
   /**
@@ -630,7 +625,7 @@ var googleAds = {
       logMessage(1, `Excluded ${event.event} due to lack of identifiers`);
       return;
     }
-    const tokenData = await fetchGoogleAdsToken(config);
+    const tokenData = await this.getToken(config);
     data.conversionAction = `customers/${config.customerId}/conversionActions/${config.conversionId}`;
     const body = {
       conversions: [data],
@@ -643,6 +638,7 @@ var googleAds = {
       headers: {
         // eslint-disable-next-line @typescript-eslint/naming-convention
         Authorization: `Bearer ${tokenData.token}`,
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         "developer-token": config.client.developerToken
       },
       body: JSON.stringify(body)
@@ -651,23 +647,68 @@ var googleAds = {
     const response = await fetch(baseUrl, requestOptions);
     const responseJson = await response.json();
     const knownErrors = [
-      "The imported event has a conversion_date_time that precedes the click. Make sure your conversion_date_time is correct and try again., at conversions[0].conversion_date_time",
-      "The click ID or call is associated with an Ads account you don't have access to. Make sure you import conversions for accounts managed by your manager account., at conversions[0].gclid",
-      "The imported event can't be recorded because its click occurred before this conversion's click-through window. Make sure you import the most recent data., at conversions[0].gclid",
-      "The imported event includes an order ID that was previously recorded, so the event was not processed., at conversions[0].order_id",
-      "The imported event could not be attributed to a click. This may be because the event did not come from a Google Ads campaign., at conversions[0].gclid",
-      "The imported event can't be recorded because its click occurred before this conversion's click-through window. Make sure you import the most recent data., at conversions[0].conversion_action"
+      "The imported event has a conversion_date_time that precedes the click. Make sure your conversion_date_time is correct and try again.",
+      "The click ID or call is associated with an Ads account you don't have access to. Make sure you import conversions for accounts managed by your manager account.",
+      "The imported event can't be recorded because its click occurred before this conversion's click-through window. Make sure you import the most recent data.",
+      "The imported event includes an order ID that was previously recorded, so the event was not processed.",
+      "The imported event could not be attributed to a click. This may be because the event did not come from a Google Ads campaign.",
+      "The imported event can't be recorded because its click occurred before this conversion's click-through window. Make sure you import the most recent data."
     ];
     if (responseJson.partialFailureError) {
       logMessage(1, responseJson.partialFailureError.message);
-      if (!knownErrors.includes(responseJson.partialFailureError.message)) {
+      const trimmedMessage = responseJson.partialFailureError.message.split("., at")[0] ?? "";
+      if (!knownErrors.includes(trimmedMessage)) {
         throw new Error(responseJson.partialFailureError.message);
       }
     } else if (responseJson.error) {
       throw new Error(responseJson.error.message);
     } else {
-      logEvent(this.source, event.event, event.region);
+      logEvent(
+        this.source,
+        event.event,
+        event.region,
+        response.status,
+        requestOptions.body
+      );
+    }
+  },
+  async getToken(config) {
+    if (tokenCache && tokenCache.createdAt + 3500 * 1e3 > Date.now()) {
+      return tokenCache;
+    }
+    if (!tokenPromise) {
+      tokenPromise = (async () => {
+        const tokenResponse = await fetch(
+          `https://oauth2.googleapis.com/token`,
+          {
+            method: "POST",
+            headers: {
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              client_id: config.client.id,
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              client_secret: config.client.secret,
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              refreshToken: config.refreshToken,
+              // eslint-disable-next-line @typescript-eslint/naming-convention
+              grant_type: "refresh_token"
+            })
+          }
+        );
+        if (!tokenResponse.ok) {
+          throw new Error("Access token fetch failed");
+        }
+        const parsedTokenResponse = await tokenResponse.json();
+        const createdAt = Date.now();
+        tokenCache = { token: parsedTokenResponse.access_token, createdAt };
+        tokenPromise = null;
+        return tokenCache;
+      })();
     }
+    return tokenPromise;
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mhubcloud/tms_core",
-  "version": "3.4.0-beta.3",
+  "version": "3.4.0-beta.5",
   "description": "Core function for mHub Cloud TMS publishers",
   "homepage": "https://mhubcloud.com/",
   "license": "Apache 2.0",

package/src/broker.ts

@@ -5,140 +5,176 @@ import * as utils from './utils/utils';
 const serviceBusConnectionString = process.env.ServiceBusConnectionString;
 const cosmosConnectionString = process.env.CosmosDbConnectionString;
 const cosmosDatabaseName = process.env.CosmosDbDatabaseName;
-const cosmosContainerName = process.env.CosmosEventsContainerName;
+const cosmosContainerName = process.env.CosmosDbEventsContainerName;
 let serviceBusClient: ServiceBusClient | undefined;
 let cosmosClient: CosmosClient | undefined;
 const senders: Record<string, ServiceBusSender> = {};
 
-type PublisherConfig = Record<string, string[] | string[][]>;
-
-export const broker = {
-  /**
-   * Evaluates an event against publisher configurations
-   * @param eventCode event.code parameter of the event
-   * @param publisherConfig object containing publisher event consumption configurations
-   * @returns list of publishers for which an event is relevant.
-   */
-  resolveEvent: function (
-    eventCode: string,
-    publisherConfig?: PublisherConfig,
-  ) {
-    if (!publisherConfig) {
-      const envConfig = process.env.Broker_PublisherConfig;
-      publisherConfig = envConfig ? JSON.parse(envConfig) : {};
-    }
+type PublisherConfig = Record<
+  string,
+  string | [string, PublisherEvent[]] | PublisherEvent[]
+>;
 
-    const publishers = [];
-
-    for (const publisher of Object.keys(publisherConfig)) {
-      const publisherEvents = publisherConfig[publisher];
-      if (publisherEvents) {
-        if (publisherEvents[0] === '*') {
-          let matchesExcluded = false;
-          // Checking whether event matches any of the excluded events
-          if (
-            Array.isArray(publisherEvents[1]) &&
-            publisherEvents[1].length > 0
-          ) {
-            for (const event of publisherEvents[1]) {
-              if (matchesExcluded) {
-                break;
-              }
-
-              if (typeof event === 'string') {
-                const regex = new RegExp(event);
-                matchesExcluded = regex.test(eventCode);
-              }
-            }
-          }
-          if (!matchesExcluded) {
-            publishers.push(publisher);
-          }
-        } else {
-          let match = false;
+type PublisherEvent = Record<string, string>;
+interface EventInfo {
+  code: string;
+  [key: string]: string;
+}
 
-          for (const event of publisherEvents) {
-            if (typeof event === 'string') {
-              const regex = new RegExp(event);
-              match = regex.test(eventCode);
-            }
+/**
+ * Evaluates an event against publisher configurations
+ * @param eventCode event.code parameter of the event
+ * @param publisherConfig object containing publisher event consumption configurations
+ * @returns list of publishers for which an event is relevant.
+ */
+export function resolveEvent(
+  event: EventInfo,
+  publisherConfig?: PublisherConfig,
+) {
+  if (!publisherConfig) {
+    const envConfig = process.env.Broker_PublisherConfig;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    publisherConfig = envConfig ? JSON.parse(envConfig) : {};
+  }
 
-            if (match) {
-              publishers.push(publisher);
+  const publishers = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  for (const publisher of Object.keys(publisherConfig!)) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const publisherEvents = publisherConfig![publisher];
+    if (publisherEvents) {
+      if (publisherEvents[0] === '*') {
+        let matchesExcluded = false;
+        // Checking whether event matches any of the excluded events
+        if (
+          Array.isArray(publisherEvents[1]) &&
+          publisherEvents[1].length > 0
+        ) {
+          for (const publisherEvent of publisherEvents[1]) {
+            if (matchesExcluded) {
+              break;
             }
+
+            matchesExcluded = matchEvent(event, publisherEvent);
+          }
+        }
+        if (!matchesExcluded) {
+          publishers.push(publisher);
+        }
+      } else {
+        let match = false;
+
+        for (const publisherEvent of publisherEvents) {
+          if (Array.isArray(publisherEvent)) {
+            continue;
+          }
+          match = matchEvent(event, publisherEvent);
+          if (match) {
+            publishers.push(publisher);
           }
         }
       }
     }
+  }
 
-    if (publishers.length === 0) {
-      return null;
-    }
+  if (publishers.length === 0) {
+    return null;
+  }
 
-    return publishers;
-  },
-
-  /**
-   * Sends an event to Service Bus
-   * @param message event to be sent
-   * @param queues list of Service Bus queues to send the event to
-   */
-  dispatchEvent: async function (
-    message: Record<string, string>,
-    queues: string[],
-  ) {
-    if (!serviceBusClient) {
-      if (!serviceBusConnectionString) {
-        throw new Error('Service Bus connection string is missing.');
-      }
-      serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
-    }
+  return publishers;
+}
 
-    await Promise.all(
-      queues.map(async (queue) => {
-        try {
-          let sender;
-          if (senders[queue]) {
-            sender = senders[queue];
-          } else {
-            senders[queue] = serviceBusClient!.createSender(queue);
-            sender = senders[queue];
-          }
-          await sender.sendMessages({ body: message });
-        } catch (e) {
-          console.log(`Sending to queue ${queue} failed`);
+function matchEvent(event: EventInfo, publisherEvent: string | PublisherEvent) {
+  if (typeof publisherEvent === 'string') {
+    const regex = new RegExp(publisherEvent);
+    const match = regex.test(event.code);
+    return match;
+  } else if (typeof publisherEvent === 'object') {
+    let paramMatch = true;
+    for (const key of Object.keys(publisherEvent)) {
+      const publisherEventParam = publisherEvent[key];
+      const eventParam = event[key];
+      if (
+        typeof publisherEventParam === 'string' &&
+        typeof eventParam === 'string'
+      ) {
+        const regex = new RegExp(publisherEventParam);
+        paramMatch = regex.test(eventParam);
+        if (!paramMatch) {
+          return false;
         }
-      }),
-    );
-  },
-
-  /**
-   * Logs an event to Cosmos DB
-   * @param message event to be logged
-   */
-  logToCosmosDb: async function (message: ServiceBusMessage) {
-    if (!cosmosClient) {
-      if (!cosmosConnectionString) {
-        throw new Error('Cosmos DB connection string is missing.');
+      } else {
+        throw new Error('Unexpected formatting in publisher configuration');
       }
-      cosmosClient = new CosmosClient(cosmosConnectionString);
     }
+    return true;
+  } else {
+    throw new Error('Unexpected formatting in publisher configuration');
+  }
+}
 
-    if (!cosmosDatabaseName) {
-      throw new Error('Cosmos DB database name is missing.');
+/**
+ * Sends an event to Service Bus
+ * @param message event to be sent
+ * @param queues list of Service Bus queues to send the event to
+ */
+export async function dispatchEvent(
+  message: Record<string, string>,
+  queues: string[],
+) {
+  if (!serviceBusClient) {
+    if (!serviceBusConnectionString) {
+      throw new Error('Service Bus connection string is missing.');
     }
+    serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
+  }
 
-    if (!cosmosContainerName) {
-      throw new Error('Cosmos DB events container name is missing.');
-    }
+  await Promise.all(
+    queues.map(async (queue) => {
+      try {
+        let sender;
+        if (senders[queue]) {
+          sender = senders[queue];
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          senders[queue] = serviceBusClient!.createSender(queue);
+          sender = senders[queue];
+        }
+        await sender.sendMessages({ body: message });
+      } catch (e) {
+        console.log(`Sending to queue ${queue} failed`);
+      }
+    }),
+  );
+}
 
-    try {
-      await cosmosClient
-        .database(cosmosDatabaseName)
-        .container(cosmosContainerName)
-        .items.create(message);
-    } catch (e) {
-      utils.logException(e as Error);
+/**
+ * Logs an event to Cosmos DB
+ * @param message event to be logged
+ */
+export async function logToCosmosDb(message: ServiceBusMessage) {
+  if (!cosmosClient) {
+    if (!cosmosConnectionString) {
+      throw new Error('Cosmos DB connection string is missing.');
     }
-  },
-};
+    cosmosClient = new CosmosClient(cosmosConnectionString);
+  }
+
+  if (!cosmosDatabaseName) {
+    throw new Error('Cosmos DB database name is missing.');
+  }
+
+  if (!cosmosContainerName) {
+    throw new Error('Cosmos DB events container name is missing.');
+  }
+
+  try {
+    await cosmosClient
+      .database(cosmosDatabaseName)
+      .container(cosmosContainerName)
+      .items.create(message);
+  } catch (e) {
+    utils.logException(e as Error);
+  }
+}