@mcesystems/logging-g4 1.0.70 → 1.0.72

package/dist/index.mjs

@@ -20275,55 +20275,172 @@ var require_src = __commonJS2({
   }
 });
 var import_debug = __toESM2(require_src());
-var logInfo = (0, import_debug.default)("info");
-var logTask = (0, import_debug.default)("task");
-var logError = (0, import_debug.default)("error");
-var logDetail = (0, import_debug.default)("detail");
-var logDebug = (0, import_debug.default)("debug");
-var logWarning = (0, import_debug.default)("warning");
-var logColor = (0, import_debug.default)("color");
-logInfo.color = "19";
-logTask.color = "25";
-logError.color = "1";
-logDetail.color = "199";
-logWarning.color = "186";
-logDebug.color = "211";
-logColor.enabled = true;
-function logNamespace(namespace) {
-  logInfo.namespace = `${namespace}:info`;
-  logTask.namespace = `${namespace}:task`;
-  logError.namespace = `${namespace}:error`;
-  logDetail.namespace = `${namespace}:detail`;
-  logWarning.namespace = `${namespace}:warning`;
-  logDebug.namespace = `${namespace}:debug`;
-}
-function setLogLevel(level) {
-  switch (level) {
-    case "info":
-      logInfo.enabled = true;
-      logTask.enabled = true;
-      logError.enabled = true;
-      logWarning.enabled = true;
-      logDetail.enabled = false;
-      logDebug.enabled = false;
-      break;
-    case "debug":
-      logInfo.enabled = true;
-      logTask.enabled = true;
-      logError.enabled = true;
-      logWarning.enabled = true;
-      logDetail.enabled = true;
-      logDebug.enabled = true;
-      break;
-    case "none":
-      logInfo.enabled = false;
-      logTask.enabled = false;
-      logError.enabled = false;
-      logWarning.enabled = false;
-      logDetail.enabled = false;
-      logDebug.enabled = false;
-      break;
+function createLoggers(namespace, logLevel = process.env.LOG_LEVEL ?? "none") {
+  const logInfo22 = (0, import_debug.default)(`${namespace}:info`);
+  const logTask = (0, import_debug.default)(`${namespace}:task`);
+  const logError2 = (0, import_debug.default)(`${namespace}:error`);
+  const logDetail2 = (0, import_debug.default)(`${namespace}:detail`);
+  const logDebug = (0, import_debug.default)(`${namespace}:debug`);
+  const logWarning = (0, import_debug.default)(`${namespace}:warning`);
+  const logColor = (0, import_debug.default)(`${namespace}:color`);
+  logInfo22.color = "19";
+  logTask.color = "25";
+  logError2.color = "1";
+  logDetail2.color = "199";
+  logWarning.color = "186";
+  logDebug.color = "211";
+  logColor.enabled = true;
+  function setNamespace(namespace2) {
+    logInfo22.namespace = `${namespace2}:info`;
+    logTask.namespace = `${namespace2}:task`;
+    logError2.namespace = `${namespace2}:error`;
+    logDetail2.namespace = `${namespace2}:detail`;
+    logWarning.namespace = `${namespace2}:warning`;
+    logDebug.namespace = `${namespace2}:debug`;
+  }
+  function setLogLevel(level) {
+    switch (level) {
+      case "info":
+        logInfo22.enabled = true;
+        logTask.enabled = true;
+        logError2.enabled = true;
+        logWarning.enabled = true;
+        logDetail2.enabled = false;
+        logDebug.enabled = false;
+        break;
+      case "debug":
+        logInfo22.enabled = true;
+        logTask.enabled = true;
+        logError2.enabled = true;
+        logWarning.enabled = true;
+        logDetail2.enabled = true;
+        logDebug.enabled = true;
+        break;
+      case "none":
+        logInfo22.enabled = false;
+        logTask.enabled = false;
+        logError2.enabled = false;
+        logWarning.enabled = false;
+        logDetail2.enabled = false;
+        logDebug.enabled = false;
+        break;
+    }
+  }
+  setLogLevel(logLevel);
+  function setColors(type, color) {
+    switch (type) {
+      case "info":
+        logInfo22.color = color;
+        break;
+      case "task":
+        logTask.color = color;
+        break;
+      case "error":
+        logError2.color = color;
+        break;
+      case "detail":
+        logDetail2.color = color;
+        break;
+      case "warning":
+        logWarning.color = color;
+        break;
+      case "debug":
+        logDebug.color = color;
+        break;
+      default:
+        throw new Error(`Invalid log type: ${type}`);
+    }
+  }
+  function printColors() {
+    for (let i = 0; i < 256; i++) {
+      logColor.color = `${i}`;
+      logColor(`${i}: ${i}`);
+    }
+  }
+  function logDataDetail(data, prefix = "#  ") {
+    if (data === null || data === void 0) {
+      return `${prefix}<null or undefined>`;
+    }
+    if (typeof data !== "object") {
+      return `${prefix}${String(data)}`;
+    }
+    const keys = Object.keys(data);
+    let result = "";
+    for (const key of keys) {
+      result += `${prefix}${key}: `;
+      if (key in data) {
+        let dataKey = key;
+        if (key in data) {
+          dataKey = key;
+          const value = data[dataKey];
+          if (value === null || value === void 0) {
+            result += `<${value === null ? "null" : "undefined"}>
+`;
+          } else if (typeof value === "object") {
+            result += `
+					${logDataDetail(value, `${prefix}   `)}
+`;
+          } else {
+            result += `${value}
+`;
+          }
+        }
+      }
+    }
+    return result.trim();
+  }
+  function header(title, padding = 0) {
+    return `${" ".repeat(padding)}${"=".repeat(80)}
+${" ".repeat(40 - title.length / 2)}${title}
+${" ".repeat(padding)}${"=".repeat(80)}`;
+  }
+  function logHeader(title) {
+    logInfo22(`${header(title, 2)}`);
+  }
+  function logDataObject2(title, ...args) {
+    const stack = new Error().stack?.split("\n")[2] || "";
+    const stackMatch = stack.match(/\((.*):(\d+):(\d+)\)$/) || stack.match(/at (.*):(\d+):(\d+)$/);
+    let callerDetails = "";
+    if (stackMatch) {
+      const functionMatch = stack.match(/at (.+) \(/);
+      const functionName = functionMatch ? functionMatch[1] : "<anonymous>";
+      callerDetails = `${functionName}`;
+    }
+    logDetail2(`${header(`*${title}* ${callerDetails}`)}
+${args.reduce((acc, arg) => `${acc}
+${logDataDetail(arg)}`, "")}
+	
+${"=".repeat(80)}`);
+  }
+  function logErrorObject2(error, extraDetails) {
+    if (error instanceof Error) {
+      logError2(`${extraDetails ? header(extraDetails, 1) : header(error.message, 1)}
+		Error Message:
+		${error.message}
+		Error Stack:
+		${error.stack}
+		${"=".repeat(80)}`);
+    } else {
+      logError2(`${extraDetails ? header(extraDetails, 1) : header(String(error), 1)}
+		${"=".repeat(80)}`);
+    }
   }
+  return {
+    logInfo: logInfo22,
+    logTask,
+    logError: logError2,
+    logDetail: logDetail2,
+    logDebug,
+    logWarning,
+    logColor,
+    setColors,
+    printColors,
+    logHeader,
+    logDataObject: logDataObject2,
+    logErrorObject: logErrorObject2,
+    setLogLevel,
+    setNamespace
+  };
 }
 var AUTHORIZE_QUERY = `
   query Authorize($input: AuthorizeInput!) {
@@ -20342,8 +20459,7 @@ var TOKEN_QUERY = `
     }
   }
 `;
-setLogLevel(process.env.LOG_LEVEL ?? "none");
-logNamespace("auth");
+var { logInfo } = createLoggers("auth");
 var random = promisify(randomBytes);
 async function getAuthToken(credentials, apiUrl) {
   const authApiUrl = apiUrl || process.env.AUTH_API_URL;
@@ -21264,120 +21380,172 @@ var require_src4 = __commonJS3({
   }
 });
 var import_debug2 = __toESM3(require_src4());
-var logInfo2 = (0, import_debug2.default)("info");
-var logTask2 = (0, import_debug2.default)("task");
-var logError2 = (0, import_debug2.default)("error");
-var logDetail2 = (0, import_debug2.default)("detail");
-var logDebug2 = (0, import_debug2.default)("debug");
-var logWarning2 = (0, import_debug2.default)("warning");
-var logColor2 = (0, import_debug2.default)("color");
-logInfo2.color = "19";
-logTask2.color = "25";
-logError2.color = "1";
-logDetail2.color = "199";
-logWarning2.color = "186";
-logDebug2.color = "211";
-logColor2.enabled = true;
-function logNamespace2(namespace) {
-  logInfo2.namespace = `${namespace}:info`;
-  logTask2.namespace = `${namespace}:task`;
-  logError2.namespace = `${namespace}:error`;
-  logDetail2.namespace = `${namespace}:detail`;
-  logWarning2.namespace = `${namespace}:warning`;
-  logDebug2.namespace = `${namespace}:debug`;
-}
-function setLogLevel2(level) {
-  switch (level) {
-    case "info":
-      logInfo2.enabled = true;
-      logTask2.enabled = true;
-      logError2.enabled = true;
-      logWarning2.enabled = true;
-      logDetail2.enabled = false;
-      logDebug2.enabled = false;
-      break;
-    case "debug":
-      logInfo2.enabled = true;
-      logTask2.enabled = true;
-      logError2.enabled = true;
-      logWarning2.enabled = true;
-      logDetail2.enabled = true;
-      logDebug2.enabled = true;
-      break;
-    case "none":
-      logInfo2.enabled = false;
-      logTask2.enabled = false;
-      logError2.enabled = false;
-      logWarning2.enabled = false;
-      logDetail2.enabled = false;
-      logDebug2.enabled = false;
-      break;
-  }
-}
-function logDataDetail(data, prefix = "#  ") {
-  if (data === null || data === void 0) {
-    return `${prefix}<null or undefined>`;
-  }
-  if (typeof data !== "object") {
-    return `${prefix}${String(data)}`;
-  }
-  const keys = Object.keys(data);
-  let result = "";
-  for (const key of keys) {
-    result += `${prefix}${key}: `;
-    if (key in data) {
-      let dataKey = key;
+function createLoggers2(namespace, logLevel = process.env.LOG_LEVEL ?? "none") {
+  const logInfo3 = (0, import_debug2.default)(`${namespace}:info`);
+  const logTask = (0, import_debug2.default)(`${namespace}:task`);
+  const logError2 = (0, import_debug2.default)(`${namespace}:error`);
+  const logDetail2 = (0, import_debug2.default)(`${namespace}:detail`);
+  const logDebug = (0, import_debug2.default)(`${namespace}:debug`);
+  const logWarning = (0, import_debug2.default)(`${namespace}:warning`);
+  const logColor = (0, import_debug2.default)(`${namespace}:color`);
+  logInfo3.color = "19";
+  logTask.color = "25";
+  logError2.color = "1";
+  logDetail2.color = "199";
+  logWarning.color = "186";
+  logDebug.color = "211";
+  logColor.enabled = true;
+  function setNamespace(namespace2) {
+    logInfo3.namespace = `${namespace2}:info`;
+    logTask.namespace = `${namespace2}:task`;
+    logError2.namespace = `${namespace2}:error`;
+    logDetail2.namespace = `${namespace2}:detail`;
+    logWarning.namespace = `${namespace2}:warning`;
+    logDebug.namespace = `${namespace2}:debug`;
+  }
+  function setLogLevel(level) {
+    switch (level) {
+      case "info":
+        logInfo3.enabled = true;
+        logTask.enabled = true;
+        logError2.enabled = true;
+        logWarning.enabled = true;
+        logDetail2.enabled = false;
+        logDebug.enabled = false;
+        break;
+      case "debug":
+        logInfo3.enabled = true;
+        logTask.enabled = true;
+        logError2.enabled = true;
+        logWarning.enabled = true;
+        logDetail2.enabled = true;
+        logDebug.enabled = true;
+        break;
+      case "none":
+        logInfo3.enabled = false;
+        logTask.enabled = false;
+        logError2.enabled = false;
+        logWarning.enabled = false;
+        logDetail2.enabled = false;
+        logDebug.enabled = false;
+        break;
+    }
+  }
+  setLogLevel(logLevel);
+  function setColors(type, color) {
+    switch (type) {
+      case "info":
+        logInfo3.color = color;
+        break;
+      case "task":
+        logTask.color = color;
+        break;
+      case "error":
+        logError2.color = color;
+        break;
+      case "detail":
+        logDetail2.color = color;
+        break;
+      case "warning":
+        logWarning.color = color;
+        break;
+      case "debug":
+        logDebug.color = color;
+        break;
+      default:
+        throw new Error(`Invalid log type: ${type}`);
+    }
+  }
+  function printColors() {
+    for (let i = 0; i < 256; i++) {
+      logColor.color = `${i}`;
+      logColor(`${i}: ${i}`);
+    }
+  }
+  function logDataDetail(data, prefix = "#  ") {
+    if (data === null || data === void 0) {
+      return `${prefix}<null or undefined>`;
+    }
+    if (typeof data !== "object") {
+      return `${prefix}${String(data)}`;
+    }
+    const keys = Object.keys(data);
+    let result = "";
+    for (const key of keys) {
+      result += `${prefix}${key}: `;
       if (key in data) {
-        dataKey = key;
-        const value = data[dataKey];
-        if (value === null || value === void 0) {
-          result += `<${value === null ? "null" : "undefined"}>
+        let dataKey = key;
+        if (key in data) {
+          dataKey = key;
+          const value = data[dataKey];
+          if (value === null || value === void 0) {
+            result += `<${value === null ? "null" : "undefined"}>
 `;
-        } else if (typeof value === "object") {
-          result += `
-${logDataDetail(value, `${prefix}   `)}
+          } else if (typeof value === "object") {
+            result += `
+					${logDataDetail(value, `${prefix}   `)}
 `;
-        } else {
-          result += `${value}
+          } else {
+            result += `${value}
 `;
+          }
         }
       }
     }
+    return result.trim();
   }
-  return result.trim();
-}
-function header(title, padding = 0) {
-  return `${" ".repeat(padding)}${"=".repeat(80)}
+  function header(title, padding = 0) {
+    return `${" ".repeat(padding)}${"=".repeat(80)}
 ${" ".repeat(40 - title.length / 2)}${title}
 ${" ".repeat(padding)}${"=".repeat(80)}`;
-}
-function logDataObject(title, ...args) {
-  const stack = new Error().stack?.split("\n")[2] || "";
-  const stackMatch = stack.match(/\((.*):(\d+):(\d+)\)$/) || stack.match(/at (.*):(\d+):(\d+)$/);
-  let callerDetails = "";
-  if (stackMatch) {
-    const functionMatch = stack.match(/at (.+) \(/);
-    const functionName = functionMatch ? functionMatch[1] : "<anonymous>";
-    callerDetails = `${functionName}`;
-  }
-  logDetail2(`${header(`*${title}* ${callerDetails}`)}
+  }
+  function logHeader(title) {
+    logInfo3(`${header(title, 2)}`);
+  }
+  function logDataObject2(title, ...args) {
+    const stack = new Error().stack?.split("\n")[2] || "";
+    const stackMatch = stack.match(/\((.*):(\d+):(\d+)\)$/) || stack.match(/at (.*):(\d+):(\d+)$/);
+    let callerDetails = "";
+    if (stackMatch) {
+      const functionMatch = stack.match(/at (.+) \(/);
+      const functionName = functionMatch ? functionMatch[1] : "<anonymous>";
+      callerDetails = `${functionName}`;
+    }
+    logDetail2(`${header(`*${title}* ${callerDetails}`)}
 ${args.reduce((acc, arg) => `${acc}
 ${logDataDetail(arg)}`, "")}
-
+	
 ${"=".repeat(80)}`);
-}
-function logErrorObject(error, extraDetails) {
-  if (error instanceof Error) {
-    logError2(`${extraDetails ? header(extraDetails, 1) : header(error.message, 1)}
-   Error Message:
-   ${error.message}
-   Error Stack:
-   ${error.stack}
- ${"=".repeat(80)}`);
-  } else {
-    logError2(`${extraDetails ? header(extraDetails, 1) : header(String(error), 1)}
- ${"=".repeat(80)}`);
   }
+  function logErrorObject2(error, extraDetails) {
+    if (error instanceof Error) {
+      logError2(`${extraDetails ? header(extraDetails, 1) : header(error.message, 1)}
+		Error Message:
+		${error.message}
+		Error Stack:
+		${error.stack}
+		${"=".repeat(80)}`);
+    } else {
+      logError2(`${extraDetails ? header(extraDetails, 1) : header(String(error), 1)}
+		${"=".repeat(80)}`);
+    }
+  }
+  return {
+    logInfo: logInfo3,
+    logTask,
+    logError: logError2,
+    logDetail: logDetail2,
+    logDebug,
+    logWarning,
+    logColor,
+    setColors,
+    printColors,
+    logHeader,
+    logDataObject: logDataObject2,
+    logErrorObject: logErrorObject2,
+    setLogLevel,
+    setNamespace
+  };
 }
 
 // ../../node_modules/.pnpm/uuid@13.0.0/node_modules/uuid/dist-node/stringify.js
@@ -21434,16 +21602,79 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
+// src/logic/cronSchedule.ts
+function getNextCronRun(intervalMs) {
+  const now = Date.now();
+  const midnight = new Date(now);
+  midnight.setHours(0, 0, 0, 0);
+  const msSinceMidnight = now - midnight.getTime();
+  const nextBoundaryMs = Math.ceil(msSinceMidnight / intervalMs) * intervalMs;
+  let nextRun = midnight.getTime() + nextBoundaryMs;
+  if (nextRun <= now) {
+    nextRun += intervalMs;
+  }
+  return nextRun;
+}
+
+// src/logic/pendingEventsStorage.ts
+import { readFile, unlink, writeFile } from "node:fs/promises";
+async function readPendingEvents(filePath) {
+  try {
+    const data = await readFile(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function writePendingEvents(filePath, events) {
+  await writeFile(filePath, JSON.stringify(events), "utf-8");
+}
+async function deletePendingEvents(filePath) {
+  try {
+    await unlink(filePath);
+  } catch (error) {
+    const err = error;
+    if (err.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
 // src/logic/logClient.ts
+var { logInfo: logInfo2, logError, logErrorObject, logDetail, logDataObject } = createLoggers2("logging");
 var LogClient = class {
   credentials;
   loggingClient;
-  offlinetime;
   cachedEvents = [];
   initialized = false;
+  firstOfflineTime;
+  sendTimeoutId;
+  timeBetweenLogMs;
+  maxOfflineTimeMs;
+  pendingEventsPath;
+  sendInProgress = false;
+  schedulerStarted = false;
   async init() {
-    setLogLevel2(process.env.LOG_LEVEL ?? "none");
-    logNamespace2("logging");
+    if (typeof this.timeBetweenLogMs !== "number") {
+      const DEFAULT_TIME_BETWEEN_LOG_MS = 10 * 60 * 1e3;
+      const DEFAULT_MAX_OFFLINE_TIME_MS = 60 * 60 * 1e3;
+      const timeBetweenLog = process.env.TIME_BETWEEN_LOG;
+      const maxOfflineTime = process.env.MAX_OFFLINE_TIME;
+      const cachedEventsPath = process.env.CACHED_EVENTS_PATH;
+      if (!cachedEventsPath) {
+        throw new Error("CACHED_EVENTS_PATH must be set");
+      }
+      this.timeBetweenLogMs = Number(timeBetweenLog) || DEFAULT_TIME_BETWEEN_LOG_MS;
+      this.maxOfflineTimeMs = Number(maxOfflineTime) || DEFAULT_MAX_OFFLINE_TIME_MS;
+      this.pendingEventsPath = cachedEventsPath;
+      if (!Number.isFinite(this.timeBetweenLogMs) || this.timeBetweenLogMs <= 0 || !Number.isFinite(this.maxOfflineTimeMs) || this.maxOfflineTimeMs <= 0) {
+        throw new Error("TIME_BETWEEN_LOG and MAX_OFFLINE_TIME must be positive numbers");
+      }
+    }
     const os4 = await import("node:os");
     const path = await import("node:path");
     const fs = await import("node:fs/promises");
@@ -21456,7 +21687,7 @@ var LogClient = class {
       const tokenData = await fs.readFile(tokenFilePath, "utf-8");
       tokenFile = JSON.parse(tokenData);
       logInfo2(`Loaded token from temp file: ${tokenFilePath}`);
-      logDetail2(
+      logDetail(
         `Token will expire ${(tokenFile.time + tokenFile.token.expiresIn * 1e3 - Date.now()) / (1e3 * 60)} minutes`
       );
     } catch (_error) {
@@ -21482,18 +21713,81 @@ var LogClient = class {
     } else {
       token = tokenFile.token;
     }
-    if (!token) {
-      throw new Error("Token not found");
-    }
-    try {
+    if (token) {
       const loggingApi = process.env.LOGGING_API_URL ?? "";
       if (!loggingApi) {
         throw new Error("LOGGING_API_URL is not set");
       }
       this.loggingClient = new import_gql_logging_client.default(loggingApi, token.accessToken);
       this.initialized = true;
-    } catch (error) {
-      logError2("Check your internet connection", error);
+    } else {
+      logError("Check your internet connection - token not found");
+    }
+    if (!this.schedulerStarted) {
+      this.schedulerStarted = true;
+      this.scheduleNextRun();
+    }
+  }
+  scheduleNextRun() {
+    if (this.sendTimeoutId !== void 0) {
+      clearTimeout(this.sendTimeoutId);
+      this.sendTimeoutId = void 0;
+    }
+    const nextRun = getNextCronRun(this.timeBetweenLogMs);
+    const delay = Math.max(0, nextRun - Date.now());
+    this.sendTimeoutId = setTimeout(() => {
+      void this.runScheduledSend();
+    }, delay);
+  }
+  async runScheduledSend() {
+    try {
+      await this.sendBatch();
+    } catch {
+      this.sendTimeoutId = void 0;
+      return;
+    }
+    this.scheduleNextRun();
+  }
+  async sendBatch() {
+    if (this.sendInProgress) {
+      return;
+    }
+    this.sendInProgress = true;
+    try {
+      const loaded = await readPendingEvents(this.pendingEventsPath);
+      const batch = [...this.cachedEvents, ...loaded];
+      this.cachedEvents = [];
+      if (batch.length === 0) {
+        this.firstOfflineTime = void 0;
+        return;
+      }
+      if (!this.loggingClient) {
+        if (this.firstOfflineTime === void 0) {
+          this.firstOfflineTime = Date.now();
+        }
+        await writePendingEvents(this.pendingEventsPath, batch);
+        if (Date.now() - this.firstOfflineTime > this.maxOfflineTimeMs) {
+          throw new Error("Exceeded max offline time");
+        }
+        return;
+      }
+      try {
+        await this.loggingClient.mutate({ events: batch }).promise();
+        await deletePendingEvents(this.pendingEventsPath);
+        this.firstOfflineTime = void 0;
+        logInfo2(`Logging batch result: ${batch.length} events sent`);
+      } catch (error) {
+        logError("Send batch failed", error);
+        if (this.firstOfflineTime === void 0) {
+          this.firstOfflineTime = Date.now();
+        }
+        await writePendingEvents(this.pendingEventsPath, batch);
+        if (Date.now() - this.firstOfflineTime > this.maxOfflineTimeMs) {
+          throw new Error("Exceeded max offline time");
+        }
+      }
+    } finally {
+      this.sendInProgress = false;
     }
   }
   async logEvent(event) {
@@ -21510,34 +21804,8 @@ var LogClient = class {
       ...event
     };
     logDataObject("Logging event", newEvent);
-    if (!this.loggingClient) {
-      logError2("Logging client not initialized");
-      if (!this.offlinetime) {
-        this.offlinetime = Date.now();
-      } else if (Date.now() - this.offlinetime > +(process.env.OFFLINE_TIME ?? 1e3 * 60 * 60)) {
-        if (process.env.APP_TYPE === "node") {
-          const { writeFile } = await import("node:fs/promises");
-          if (!process.env.CACHED_EVENTS_PATH) {
-            throw new Error("CACHED_EVENTS_PATH is not set");
-          }
-          await writeFile(
-            `${process.env.CACHED_EVENTS_PATH}-${Date.now()}.json`,
-            JSON.stringify(this.cachedEvents)
-          );
-          logInfo2(`Cached events saved to: ${process.env.CACHED_EVENTS_PATH}`);
-          this.offlinetime = Date.now();
-          this.cachedEvents = [];
-        }
-      }
-      this.cachedEvents.push(newEvent);
-      return;
-    }
-    const result = await this.loggingClient.mutate({
-      events: [newEvent, ...this.cachedEvents]
-    }).promise();
-    this.cachedEvents = [];
-    logInfo2(`Logging event result: ${JSON.stringify(result)}`);
-    return result;
+    this.cachedEvents.push(newEvent);
+    return "delayed";
   }
 };
 export {