```diff
--- test_files/438-original.txt	2025-03-07 19:07:00
+++ test_files/438-modified.txt	2025-03-07 19:07:00
@@ -1,47 +1,68 @@
-import { getEnvVariable } from './shared';
+import { getEnvVariable } from "./shared";
 
-const levels = {
-  error: 'ERROR',
-  warn: 'WARN',
-  info: 'INFO',
-  debug: 'DEBUG'
+// Define log levels with corresponding priorities
+export const LOG_LEVELS = {
+  silent: -1, // No logs
+  error: 0, // Highest priority - critical errors
+  warn: 1, // Warning messages
+  info: 2, // General information
+  debug: 3, // Debug information
+} as const;
+
+/**
+ * Get the current log level from environment variables.
+ * Defaults to 'info' if not set or invalid.
+ * @returns {keyof typeof LOG_LEVELS} The current log level
+ */
+export const getLogLevel = (): keyof typeof LOG_LEVELS => {
+  const envLevel = getEnvVariable(
+    "COMPOSIO_LOGGING_LEVEL",
+    "info"
+  )?.toLowerCase();
+  return envLevel && envLevel in LOG_LEVELS
+    ? (envLevel as keyof typeof LOG_LEVELS)
+    : "info";
 };
 
-const colors = {
-  red: (str: string) => `\x1b[31m${str}\x1b[0m`,
-  yellow: (str: string) => `\x1b[33m${str}\x1b[0m`,
-  blue: (str: string) => `\x1b[34m${str}\x1b[0m`,
-  green: (str: string) => `\x1b[32m${str}\x1b[0m`,
-  gray: (str: string) => `\x1b[90m${str}\x1b[0m`
+const addTimestampToMessage = (message: string): string => {
+  const timestamp = new Date().toISOString();
+  return `${timestamp} - ${message}`;
 };
 
-const colorize = (level: string, timestamp: string) => {
-  switch (level) {
-    case 'error':
-      return { level: colors.red(levels[level]), timestamp: colors.gray(timestamp) };
-    case 'warn':
-      return { level: colors.yellow(levels[level]), timestamp: colors.gray(timestamp) };
-    case 'info':
-      return { level: colors.blue(levels[level]), timestamp: colors.gray(timestamp) };
-    case 'debug':
-      return { level: colors.green(levels[level]), timestamp: colors.gray(timestamp) };
-    default:
-      return { level, timestamp };
-  }
+const formatErrorMessage = (args: unknown[]): string => {
+  return args
+    .map((arg) => (typeof arg === "object" ? JSON.stringify(arg) : arg))
+    .join(" ");
 };
 
-const logger = {
-  level: getEnvVariable("COMPOSIO_DEBUG", "0") === "1" ? 'debug' : 'info',
-  log: (level: string, message: string, meta?: any) => {
-    const timestamp = new Date().toLocaleTimeString();
-    const { level: coloredLevel, timestamp: coloredTimestamp } = colorize(level, timestamp);
-    const metaInfo = meta ? ` - ${JSON.stringify(meta)}` : '';
-    console.log(`[${coloredLevel}] ${coloredTimestamp} ${message}${metaInfo}`);
-  },
-  error: (message: string, meta?: any) => logger.log('error', message, meta),
-  warn: (message: string, meta?: any) => logger.log('warn', message, meta),
-  info: (message: string, meta?: any) => logger.log('info', message, meta),
-  debug: (message: string, meta?: any) => logger.log('debug', message, meta)
+const getLogger = () => {
+  const logger = console;
+  const loggingLevel = getLogLevel();
+  const logLevelValue = LOG_LEVELS[loggingLevel];
+  const noop = () => {};
+
+  return {
+    error:
+      logLevelValue >= LOG_LEVELS.error
+        ? (...args: unknown[]) =>
+            logger.error(addTimestampToMessage(formatErrorMessage(args)))
+        : noop,
+    warn:
+      logLevelValue >= LOG_LEVELS.warn
+        ? (...args: unknown[]) =>
+            logger.warn(addTimestampToMessage(formatErrorMessage(args)))
+        : noop,
+    info:
+      logLevelValue >= LOG_LEVELS.info
+        ? (...args: unknown[]) =>
+            logger.info(addTimestampToMessage(formatErrorMessage(args)))
+        : noop,
+    debug:
+      logLevelValue >= LOG_LEVELS.debug
+        ? (...args: unknown[]) =>
+            logger.debug(addTimestampToMessage(formatErrorMessage(args)))
+        : noop,
+  };
 };
 
-export default logger;
+export default getLogger();
```
