@dev-blinq/cucumber_client 1.0.1475-dev → 1.0.1475-stage

package/bin/client/recorderv3/update_feature.js

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import path from "path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
 import { getDefaultPrettierConfig } from "../code_cleanup/utils.js";
 import prettier from "prettier";
-export function containsScenario({ featureFileContent, scenarioName }) {
+
+function containsScenario({ featureFileContent, scenarioName }) {
   const lines = featureFileContent.split("\n");
   for (const line of lines) {
     const trimmedLine = line.trim();
@@ -14,7 +15,7 @@ export function containsScenario({ featureFileContent, scenarioName }) {
   }
 }
 
-export function testStringForRegex(text) {
+function testStringForRegex(text) {
   const regexEndPattern = /\/([gimuy]*)$/;
   if (text.startsWith("/")) {
     const match = regexEndPattern.test(text);
@@ -32,6 +33,7 @@ export function testStringForRegex(text) {
 }
 
 const escapeNonPrintables = (text) => {
+  if (typeof text !== "string") return text.toString();
   const t = text.replace(/\n/g, "\\n").replace(/\t/g, "\\t"); // .replace(/\|/g, "\\|");
   let result = "";
   // replace \ with \\ and | with \|
@@ -61,7 +63,8 @@ const escapeNonPrintables = (text) => {
   }
   return result;
 };
-export function getCommandContent(command) {
+
+function getCommandContent(command) {
   switch (command.type) {
     case "click_element": {
       return `${command.count === 2 ? "Double click" : "Click"} on ${escapeNonPrintables(command.element.name)}`;
@@ -108,7 +111,18 @@ export function getCommandContent(command) {
   }
 }
 
-export function getExamplesContent(parametersMap) {
+function getExamplesContent(parametersMap, datasets) {
+  if (datasets && datasets.length > 0) {
+    let result = "";
+    const keys = Object.keys(parametersMap);
+    result += "\t\tExamples:\n";
+
+    result += `\t\t| ${keys.join(" | ")} |\n`;
+    for (const dataset of datasets) {
+      result += `\t\t| ${dataset.data.map((d) => escapeNonPrintables(d.value)).join(" | ")} |\n`;
+    }
+    return result;
+  }
   const keys = Object.keys(parametersMap);
   const l = keys.length;
   let result = "\t\tExamples:\n";
@@ -144,19 +158,19 @@ function getTagsContent(scenario, featureFileObject) {
   return tagsContent;
 }
 
-export function getScenarioContent({ scenario }, featureFileObject) {
+function getScenarioContent({ scenario }, featureFileObject) {
   const prametersMap = scenario.parametersMap ?? {};
   const isParmatersMapEmpty = Object.keys(prametersMap).length === 0;
   let scenarioContent = isParmatersMapEmpty ? `Scenario: ${scenario.name}\n` : `Scenario Outline: ${scenario.name}\n`;
 
-  let tagsContent = getTagsContent(scenario, featureFileObject);
+  const tagsContent = getTagsContent(scenario, featureFileObject);
 
-  scenarioContent = "\t" + tagsContent + "\n" + scenarioContent;
+  scenarioContent = `\t${tagsContent}\n${scenarioContent}`;
 
   for (const step of scenario.steps) {
     const commands = step.commands ?? [];
-    let commentContents = commands.map(getCommandContent).map(escapeNonPrintables);
-    let commentContent = commentContents.filter((content) => content.length > 0).join(", ");
+    const commentContents = commands.map(getCommandContent).map(escapeNonPrintables);
+    const commentContent = commentContents.filter((content) => content.length > 0).join(", ");
 
     if (commentContent) {
       scenarioContent += `\t# ${commentContent}\n`;
@@ -164,18 +178,19 @@ export function getScenarioContent({ scenario }, featureFileObject) {
     scenarioContent += `\t${step.keyword} ${escapeString(step.text)}\n`;
   }
   if (!isParmatersMapEmpty) {
-    scenarioContent += getExamplesContent(prametersMap);
+    scenarioContent += getExamplesContent(prametersMap, scenario.datasets);
   }
   return scenarioContent;
 }
-export const escapeString = (str) => {
+
+function escapeString(str) {
   // Step 1: Replace all literal newline characters with a temporary placeholder
   const placeholder = "\\n";
   str = str.replace(/\n/g, placeholder);
   return str;
-};
+}
 
-const GherkinToObject = (gherkin) => {
+function GherkinToObject(gherkin) {
   const obj = {
     featureName: "",
     scenarios: [],
@@ -211,7 +226,7 @@ const GherkinToObject = (gherkin) => {
   }
 
   const getScenario = () => {
-    let scenario = {
+    const scenario = {
       name: "",
       tags: [],
       steps: [],
@@ -235,7 +250,7 @@ const GherkinToObject = (gherkin) => {
     skipEmptyLines();
 
     if (idx >= lines.length) {
-      return -1;
+      return scenario;
     }
 
     while (
@@ -288,29 +303,50 @@ const GherkinToObject = (gherkin) => {
     skipEmptyLines();
   }
   return obj;
-};
+}
 
 // remove lines starting with "Scenario:" or "Scenario Outline:" that contain the scenario name until the next scenario and then append the new scenario content
 // assumes that there are no multiple scenarios with the same name and having comments and tags in each scenario
-function updateExistingScenario({ featureFileContent, scenarioName, scenarioContent }) {
+function updateExistingScenario({
+  featureFileContent,
+  scenarioName: newScenarioName,
+  scenarioContent: newScenarioContent,
+}) {
   const featureFileObject = GherkinToObject(featureFileContent);
   if (featureFileObject.error) return "error";
+
   const results = [];
-  let skipScenarioIndex = -1;
   results.push(`Feature: ${featureFileObject.featureName}`);
+
+  let indexOfScenarioToUpdate = -1;
+
+  for (let i = 0; i < featureFileObject.scenarios.length; i++) {
+    if (featureFileObject.scenarios[i].name === newScenarioName) {
+      indexOfScenarioToUpdate = i;
+      break;
+    }
+  }
+
   for (let i = 0; i < featureFileObject.scenarios.length; i++) {
     const scenario = featureFileObject.scenarios[i];
-    if (scenario.name === scenarioName) {
-      skipScenarioIndex = i;
+
+    if (i === indexOfScenarioToUpdate) {
+      results.push("");
+      results.push(newScenarioContent.trim());
+      results.push("");
       continue;
     }
-    let scenarioContent = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
+
+    const scenarioHeader = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
     let tagsLine;
+
     if (scenario.tags?.length > 0) {
-      tagsLine = `${scenario.tags.map((t) => `@${t}`).join(" ")}`;
+      tagsLine = scenario.tags.map((t) => `@${t}`).join(" ");
     }
-    if (tagsLine) results.push("\t" + tagsLine);
-    results.push(`\t${scenarioContent}`);
+
+    if (tagsLine) results.push(`\t${tagsLine}`);
+    results.push(`\t${scenarioHeader}`);
+
     for (const step of scenario.steps) {
       if (step.type === "examples") {
         results.push(`\t\tExamples:`);
@@ -323,14 +359,12 @@ function updateExistingScenario({ featureFileContent, scenarioName, scenarioCont
     }
     results.push("");
   }
-  let finalContent = results.join("\n");
-  if (skipScenarioIndex !== -1) {
-    finalContent = results.join("\n") + "\n" + scenarioContent;
-  }
-  return finalContent;
+
+  return results.join("\n");
 }
-export async function updateFeatureFile({ featureName, scenario, override, projectDir }) {
-  const featureFilePath = path.join(projectDir, "features", featureName + ".feature");
+
+async function updateFeatureFile({ featureName, scenario, override, projectDir, logger }) {
+  const featureFilePath = path.join(projectDir, "features", `${featureName}.feature`);
   const isFeatureFileExists = existsSync(featureFilePath);
   const scenarioContent = getScenarioContent(
     { scenario },
@@ -361,13 +395,13 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
             plugins: ["prettier-plugin-gherkin"],
           });
         } catch (error) {
-          console.error("Error formatting feature file content with Prettier:", error);
+          logger.error("Error formatting feature file content with Prettier:", error);
         }
         writeFileSync(featureFilePath, updatedFeatureFileContent);
         return;
       }
     }
-    let updatedFeatureFileContent = featureFileContent + "\n" + scenarioContent;
+    let updatedFeatureFileContent = `${featureFileContent}\n${scenarioContent}`;
     try {
       updatedFeatureFileContent = await prettier.format(updatedFeatureFileContent, {
         ...prettierConfig,
@@ -375,7 +409,7 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
         plugins: ["prettier-plugin-gherkin"],
       });
     } catch (error) {
-      console.error("Error formatting feature file content with Prettier:", error);
+      logger.error("Error formatting feature file content with Prettier:", error);
     }
     writeFileSync(featureFilePath, updatedFeatureFileContent);
   } else {
@@ -387,8 +421,22 @@ export async function updateFeatureFile({ featureName, scenario, override, proje
         plugins: ["prettier-plugin-gherkin"],
       });
     } catch (error) {
-      console.error("Error formatting feature file content with Prettier:", error);
+      logger.error("Error formatting feature file content with Prettier:", error);
     }
     writeFileSync(featureFilePath, featureFileContent);
   }
 }
+
+export {
+  containsScenario,
+  testStringForRegex,
+  escapeNonPrintables,
+  getCommandContent,
+  getExamplesContent,
+  getTagsContent,
+  getScenarioContent,
+  escapeString,
+  GherkinToObject,
+  updateExistingScenario,
+  updateFeatureFile,
+};

package/bin/client/recorderv3/utils.js

@@ -0,0 +1,80 @@
+import { getErrorMessage } from "../utils/socket_logger.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import {
+  FIXED_FILE_NAMES,
+  FIXED_FOLDER_NAMES,
+  SaveJobErrorType,
+  UpdateStepDefinitionsError,
+  UTF8_ENCODING,
+} from "./constants.js";
+import url from "node:url";
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+export function handleFileInitOps(projectDir, logger) {
+  try {
+    const stepDefinitionFolderPath = path.join(
+      projectDir,
+      FIXED_FOLDER_NAMES.FEATURES,
+      FIXED_FOLDER_NAMES.STEP_DEFINITIONS
+    );
+    if (!existsSync(stepDefinitionFolderPath)) {
+      mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    }
+
+    const utilsFilePath = path.join(
+      projectDir,
+      FIXED_FOLDER_NAMES.FEATURES,
+      FIXED_FOLDER_NAMES.STEP_DEFINITIONS,
+      FIXED_FILE_NAMES.UTILS
+    );
+    const utilsTemplateFilePath = path.join(
+      __dirname,
+      `../../${FIXED_FOLDER_NAMES.ASSETS}`,
+      FIXED_FOLDER_NAMES.TEMPLATES,
+      FIXED_FILE_NAMES.UTILS_TEMPLATE
+    );
+
+    if (!existsSync(utilsTemplateFilePath)) {
+      throw new Error(`Utils template not found at: ${utilsTemplateFilePath}`);
+    }
+
+    const utilsContent = readFileSync(utilsTemplateFilePath, UTF8_ENCODING);
+    writeFileSync(utilsFilePath, utilsContent, UTF8_ENCODING);
+
+    const hooksTemplateFilePath = path.join(
+      __dirname,
+      `../../${FIXED_FOLDER_NAMES.ASSETS}`,
+      FIXED_FOLDER_NAMES.TEMPLATES,
+      FIXED_FILE_NAMES.HOOKS_TEMPLATE
+    );
+    if (existsSync(hooksTemplateFilePath)) {
+      const hooksFilePath = path.join(stepDefinitionFolderPath, FIXED_FILE_NAMES.HOOKS);
+      const hooksContent = readFileSync(hooksTemplateFilePath, UTF8_ENCODING);
+      writeFileSync(hooksFilePath, hooksContent, UTF8_ENCODING);
+    }
+
+    const featureFolder = path.join(projectDir, FIXED_FOLDER_NAMES.FEATURES);
+
+    return { featureFolder, utilsFilePath, utilsContent };
+  } catch (error) {
+    throw new UpdateStepDefinitionsError({
+      type: SaveJobErrorType.FILE_SYSTEM_ERROR,
+      message: "❌ Failed to initialize step definition folder structure",
+      meta: { reason: getErrorMessage(error) },
+    });
+  }
+}
+
+export async function potentialErrorWrapper(fn, errorMessage, type, logger) {
+  try {
+    return await fn();
+  } catch (error) {
+    logger.error(`❌ ${errorMessage}: ${getErrorMessage(error)}`);
+    throw new UpdateStepDefinitionsError({
+      type: type,
+      message: errorMessage,
+      meta: { reason: getErrorMessage(error) },
+    });
+  }
+}

package/bin/client/recorderv3/wbr_entry.js

@@ -0,0 +1,61 @@
+import { io } from "socket.io-client";
+import { BVTRecorderInit } from "./bvt_init.js";
+import { loadArgs, showUsage, validateCLIArg } from "../cli_helpers.js";
+const requiredEnvVars = ["PROJECT_ID", "BLINQ_TOKEN", "SESSION_ID", "WORKER_WS_SERVER_URL", "REMOTE_ORIGINS_URL"];
+function validateEnvVariables() {
+    const missingVars = requiredEnvVars.filter((varName) => !process.env[varName]);
+    if (missingVars.length > 0) {
+        throw new Error(`Missing required environment variables: ${missingVars.join(", ")}`);
+    }
+    else {
+        console.log("All required environment variables are set.");
+        requiredEnvVars.forEach((varName) => {
+            console.log(`${varName}: ${process.env[varName]}`);
+        });
+    }
+}
+function getEnvironmentConfig() {
+    const args = loadArgs();
+    const projectDir = args[0] || process.env.PROJECT_ID;
+    const envName = args[1]?.split("=")[1] || process.env.ENV_NAME;
+    const roomId = args[2] || process.env.SESSION_ID;
+    const shouldTakeScreenshot = args[3] || process.env.SHOULD_TAKE_SCREENSHOT;
+    const TOKEN = process.env.BLINQ_TOKEN;
+    try {
+        validateCLIArg(projectDir, "projectDir");
+        validateCLIArg(envName, "envName");
+        validateCLIArg(roomId, "roomId");
+        validateCLIArg(shouldTakeScreenshot, "shouldTakeScreenshot");
+        if (!TOKEN) {
+            throw new Error("BLINQ_TOKEN env variable not set");
+        }
+    }
+    catch (error) {
+        const usage = `Usage: node bvt_recorder.js <projectDir> <envName> <roomId>`;
+        if (error instanceof Error) {
+            showUsage(error, usage);
+        }
+        else {
+            const unknownError = new Error("An unknown error occurred");
+            showUsage(unknownError, usage);
+        }
+    }
+    return { envName, projectDir, roomId, TOKEN };
+}
+function initWebBVTRecorder() {
+    const socket = io(process.env.WORKER_WS_SERVER_URL, {
+        path: "/ws",
+        transports: ["websocket", "polling"],
+        reconnection: true,
+    });
+    validateEnvVariables();
+    const { envName, projectDir, roomId, TOKEN } = getEnvironmentConfig();
+    BVTRecorderInit({
+        envName: envName,
+        projectDir,
+        roomId,
+        TOKEN,
+        socket,
+    });
+}
+initWebBVTRecorder();

package/bin/client/recording.js

@@ -53,6 +53,7 @@ const Types = {
   SET_INPUT_FILES: "set_input_files",
   VERIFY_PAGE_SNAPSHOT: "verify_page_snapshot",
   CONDITIONAL_WAIT: "conditional_wait",
+  SLEEP: "sleep",
 };
 class Recording {
   steps = [];

package/bin/client/types/locators.js

@@ -0,0 +1,2 @@
+// Shared locator schema used by recorder, automation model, and codegen.
+export {};

package/bin/client/upload-service.js

@@ -12,6 +12,7 @@ class ScenarioUploadService {
       this.runsApiBaseURL + "/scenarios/create",
       {
         name,
+        branch: process.env.GIT_BRANCH ? process.env.GIT_BRANCH : "main",
       },
       {
         headers: {
@@ -107,6 +108,7 @@ class ScenarioUploadService {
       {
         scenarioId,
         projectId,
+        testcase_id: process.env.TESTCASE_ID,
       },
       {
         headers: {

package/bin/client/utils/app_dir.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import os from "node:os";
+function getAppDataDir(project_id) {
+    if (process.env.BLINQ_APPDATA_DIR) {
+        return path.join(process.env.BLINQ_APPDATA_DIR, "blinq.io", project_id);
+    }
+    let appDataDir;
+    switch (process.platform) {
+        case "win32":
+            appDataDir = path.join(process.env.APPDATA, "blinq.io", project_id);
+            break;
+        case "darwin":
+            appDataDir = path.join(os.homedir(), "Library", "Application Support", "blinq.io", project_id);
+            break;
+        default:
+            appDataDir = path.join(os.homedir(), ".config", "blinq.io", project_id);
+            break;
+    }
+    return appDataDir;
+}
+export { getAppDataDir };

package/bin/client/utils/socket_logger.js

@@ -1,132 +1,107 @@
-/**
- * @typedef {Object} SocketLoggerEventPayload
- * @property {string} level        Log level (e.g. "info", "warn", "error", "debug")
- * @property {string} context      Log context/subsystem (e.g. "BVTRecorder")
- * @property {*}      data         The log message payload (string, object, etc)
- * @property {string} timestamp    ISO string when the log was emitted
- * @property {number} dataSize     Size of data in bytes (-1 if unknown)
- */
-
-/**
- * @typedef {Object} SocketLoggerInitOptions
- * @property {string=} context     Default context for all logs (optional)
- * @property {string=} eventName   Default event name (default: "recorder.log")
- */
-
+function getErrorMessage(err) {
+    if (typeof err === "string") {
+        return err;
+    }
+    else if (err instanceof Error) {
+        return err.message;
+    }
+    else {
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+            return String(err);
+        }
+    }
+}
+function responseSize(response) {
+    try {
+        if (typeof response !== "string") {
+            return new Blob([JSON.stringify(response)]).size;
+        }
+        else {
+            return new Blob([response]).size;
+        }
+    }
+    catch {
+        return -1;
+    }
+}
 /**
  * SocketLogger - Singleton for structured socket-based logging.
  *
- * @namespace SocketLogger
- * @property {function(import('socket.io-client').Socket|import('socket.io').Socket, SocketLoggerInitOptions=):void} init
- * @property {function(string, (string|*), Object=, string=, string=):void} log
- * @property {function((string|*), Object=):void} info
- * @property {function((string|*), Object=):void} warn
- * @property {function((string|*), Object=):void} debug
- * @property {function((string|*), Object=):void} error
- *
  * @example
- *   import logger from "./socket_logger.js";
- *   logger.init(socket, { context: "BVTRecorder" });
- *   logger.info("Step started", { step: 2 });
- *   logger.error("Failed!", { error: "bad stuff" });
+ *   import SocketLogger from "./socket_logger";
+ *   SocketLogger.getInstance().init(socket, { context: "BVTRecorder" });
+ *   SocketLogger.getInstance().info("Step started", { step: 2 });
+ *   SocketLogger.getInstance().error("Failed!", { error: "bad stuff" });
  */
-const SocketLogger = (function () {
-  /** @type {import('socket.io-client').Socket|import('socket.io').Socket|null} */
-  let socket = null;
-  /** @type {string} */
-  let defaultContext = "";
-  /** @type {string} */
-  let defaultEventName = "recorder.log";
-
-  /**
-   * Initialize the logger (call once).
-   * @param {import('socket.io-client').Socket|import('socket.io').Socket} sock
-   * @param {SocketLoggerInitOptions=} opts
-   */
-  function init(sock, opts) {
-    socket = sock;
-    defaultContext = (opts && opts.context) || "";
-    defaultEventName = (opts && opts.eventName) || "recorder.log";
-  }
-
-  /**
-   * Low-level log method (most users use info/warn/debug/error).
-   * @param {string} level         Log level ("info", "warn", "debug", "error")
-   * @param {string|*} message     The log message or object
-   * @param {Object=} extra        Extra fields (will be merged into log payload)
-   * @param {string=} eventName    Override event name for this log (default: "recorder.log")
-   * @param {string=} context      Override log context for this log (default: set in init)
-   */
-  function log(level, message, extra, eventName, context) {
-    if (!socket || typeof socket.emit !== "function") return;
-    /** @type {*} */
-    var data = typeof message === "object" ? message : { message: message };
-    /** @type {number} */
-    var dataSize = 0;
-    try {
-      dataSize = Buffer.byteLength(JSON.stringify(data || ""), "utf8");
-    } catch (e) {
-      dataSize = -1;
+export class SocketLogger {
+    static instance;
+    socket = null;
+    defaultContext = "BVTRecorder";
+    defaultEventName = "BVTRecorder.log";
+    constructor() { }
+    static getInstance() {
+        if (!SocketLogger.instance) {
+            SocketLogger.instance = new SocketLogger();
+        }
+        return SocketLogger.instance;
     }
-    /** @type {SocketLoggerEventPayload} */
-    var eventPayload = Object.assign(
-      {
-        level: level,
-        context: context || defaultContext,
-        data: data,
-        timestamp: new Date().toISOString(),
-        dataSize: dataSize,
-      },
-      extra || {}
-    );
-    // @ts-ignore
-    try {
-      if (socket) {
-        socket.emit(eventName || defaultEventName, eventPayload);
-      }
-    } catch (e) {
-      console.error("Socket logging error:", e);
-      console.log("Socket event payload:", eventPayload);
+    init(sock, opts) {
+        this.socket = sock;
+        this.defaultContext = opts?.context || "";
+        this.defaultEventName = opts?.eventName || "recorder.log";
+    }
+    log(level, message, extra, context) {
+        if (!this.socket || typeof this.socket.emit !== "function")
+            return;
+        const data = typeof message === "object" ? message : { message };
+        let dataSize = 0;
+        try {
+            dataSize = Buffer.byteLength(JSON.stringify(data || ""), "utf8");
+        }
+        catch {
+            dataSize = -1;
+        }
+        const eventPayload = {
+            level,
+            context: context || this.defaultContext,
+            data: JSON.stringify({
+                ...data,
+                errorMessage: level === "error" && data ? getErrorMessage(data) : undefined,
+            }),
+            timestamp: new Date().toISOString(),
+            dataSize,
+            ...extra,
+        };
+        try {
+            if (this.socket) {
+                this.socket.emit(this.defaultEventName, eventPayload);
+            }
+            console.log(`${context ?? this.defaultContext} [${level.toUpperCase()}]:`, {
+                ...data,
+                ...extra,
+            });
+        }
+        catch (e) {
+            console.error("Socket logging error:", e);
+            console.log("Socket event payload:", eventPayload);
+        }
+    }
+    info(msg, ext, ctx) {
+        this.log("info", msg, ext, ctx);
+    }
+    warn(msg, ext, ctx) {
+        this.log("warn", msg, ext, ctx);
+    }
+    debug(msg, ext, ctx) {
+        this.log("debug", msg, ext, ctx);
+    }
+    error(msg, ext, ctx) {
+        this.log("error", msg, ext, ctx);
     }
-  }
-
-  /**
-   * Write an info-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function info(msg, ext) {
-    log("info", msg, ext);
-  }
-
-  /**
-   * Write a warn-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function warn(msg, ext) {
-    log("warn", msg, ext);
-  }
-
-  /**
-   * Write a debug-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function debug(msg, ext) {
-    log("debug", msg, ext);
-  }
-
-  /**
-   * Write an error-level log event.
-   * @param {string|*} msg      The message or object
-   * @param {Object=} ext       Any extra fields/metadata
-   */
-  function error(msg, ext) {
-    log("error", msg, ext);
-  }
-
-  return { init, log, info, warn, debug, error };
-})();
-
-export default SocketLogger;
+}
+const socketLoggerInstance = SocketLogger.getInstance();
+export default socketLoggerInstance;
+export { getErrorMessage, responseSize };