@withwiz/toolkit 0.1.0

package/dist/chunk-65LHDFU3.js

@@ -0,0 +1,242 @@
+import {
+  convertToBytes,
+  formatBytesPerSec,
+  runCommand,
+  runMacCommand
+} from "./chunk-KWTBD4CM.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/system/network.ts
+async function getNetworkInfo() {
+  try {
+    const platform = process.platform;
+    let connectionsOutput;
+    let processConnectionsCount = 0;
+    if (platform === "darwin") {
+      connectionsOutput = await runMacCommand("netstat -an | grep ESTABLISHED | wc -l");
+    } else {
+      connectionsOutput = await runCommand("netstat -an | grep ESTABLISHED | wc -l");
+    }
+    const pid = process.pid;
+    try {
+      if (platform === "darwin") {
+        const processOutput = await runMacCommand(`lsof -i -a -p ${pid} 2>/dev/null | grep ESTABLISHED | wc -l`);
+        processConnectionsCount = parseInt(processOutput.trim()) || 0;
+      } else {
+        try {
+          const processOutput = await runCommand(`ls -la /proc/${pid}/fd 2>/dev/null | grep socket | wc -l`);
+          processConnectionsCount = parseInt(processOutput.trim()) || 0;
+        } catch (e) {
+          const ssOutput = await runCommand(`ss -tnp 2>/dev/null | grep "pid=${pid}" | wc -l`);
+          processConnectionsCount = parseInt(ssOutput.trim()) || 0;
+        }
+      }
+    } catch (error) {
+      logger.debug("Process connections count failed:", error);
+      processConnectionsCount = 0;
+    }
+    const getProcessNetworkStats = async () => {
+      try {
+        if (platform === "darwin") {
+          try {
+            const nettopOutput = await runMacCommand(`nettop -J bytes_in,bytes_out -l 1 -p ${pid} 2>/dev/null`);
+            let totalRx = 0, totalTx = 0;
+            const lines = nettopOutput.split("\n").filter((line) => line.trim());
+            for (const line of lines) {
+              const bytesMatch = line.match(/(\d+(?:\.\d+)?)\s+(B|KiB|MiB|GiB)\s+(\d+(?:\.\d+)?)\s+(B|KiB|MiB|GiB)/);
+              if (bytesMatch) {
+                const rxValue = parseFloat(bytesMatch[1]);
+                const rxUnit = bytesMatch[2];
+                const txValue = parseFloat(bytesMatch[3]);
+                const txUnit = bytesMatch[4];
+                totalRx += convertToBytes(rxValue, rxUnit);
+                totalTx += convertToBytes(txValue, txUnit);
+              }
+            }
+            return { rx: totalRx, tx: totalTx };
+          } catch (e) {
+            return { rx: 0, tx: 0 };
+          }
+        } else {
+          try {
+            const ioOutput = await runCommand(`cat /proc/${pid}/io 2>/dev/null`);
+            let rx = 0, tx = 0;
+            const readMatch = ioOutput.match(/read_bytes:\s+(\d+)/);
+            const writeMatch = ioOutput.match(/write_bytes:\s+(\d+)/);
+            if (readMatch) rx = parseInt(readMatch[1]) || 0;
+            if (writeMatch) tx = parseInt(writeMatch[1]) || 0;
+            return { rx, tx };
+          } catch (e) {
+            return { rx: 0, tx: 0 };
+          }
+        }
+      } catch (e) {
+        return { rx: 0, tx: 0 };
+      }
+    };
+    const getNetworkStats = async () => {
+      if (platform === "darwin") {
+        try {
+          const nettopOutput = await runMacCommand("nettop -J bytes_in,bytes_out -l 1 -s 1");
+          let totalRx = 0, totalTx = 0;
+          const lines = nettopOutput.split("\n").filter((line) => line.trim());
+          for (const line of lines) {
+            const bytesMatch = line.match(/(\d+(?:\.\d+)?)\s+(B|KiB|MiB|GiB)\s+(\d+(?:\.\d+)?)\s+(B|KiB|MiB|GiB)/);
+            if (bytesMatch) {
+              const rxValue = parseFloat(bytesMatch[1]);
+              const rxUnit = bytesMatch[2];
+              const txValue = parseFloat(bytesMatch[3]);
+              const txUnit = bytesMatch[4];
+              const rxBytes = convertToBytes(rxValue, rxUnit);
+              const txBytes = convertToBytes(txValue, txUnit);
+              totalRx += rxBytes;
+              totalTx += txBytes;
+            }
+          }
+          return { rx: totalRx, tx: totalTx };
+        } catch (error) {
+          logger.debug("nettop failed, falling back to ifconfig:", error);
+          try {
+            const ifaceList = await runMacCommand("ifconfig -l");
+            const ifaces = ifaceList.split(/\s+/).filter(Boolean);
+            let maxRx = 0, maxTx = 0;
+            let found = false;
+            for (const iface of ifaces) {
+              try {
+                const ifconfigOutput = await runMacCommand(`ifconfig ${iface}`);
+                let rx = 0, tx = 0;
+                const rxMatch1 = ifconfigOutput.match(/input bytes (\d+)/);
+                const txMatch1 = ifconfigOutput.match(/output bytes (\d+)/);
+                const bytesMatch = ifconfigOutput.match(/bytes:\s*(\d+)\s+(\d+)/);
+                const rxMatch3 = ifconfigOutput.match(/RX bytes:(\d+)/);
+                const txMatch3 = ifconfigOutput.match(/TX bytes:(\d+)/);
+                if (rxMatch1 && txMatch1) {
+                  rx = parseInt(rxMatch1[1]);
+                  tx = parseInt(txMatch1[1]);
+                } else if (bytesMatch) {
+                  rx = parseInt(bytesMatch[1]);
+                  tx = parseInt(bytesMatch[2]);
+                } else if (rxMatch3 && txMatch3) {
+                  rx = parseInt(rxMatch3[1]);
+                  tx = parseInt(txMatch3[1]);
+                }
+                if (rx > 0 || tx > 0) {
+                  if (rx + tx > maxRx + maxTx) {
+                    maxRx = rx;
+                    maxTx = tx;
+                    found = true;
+                  }
+                }
+              } catch (e) {
+                logger.debug(`Error reading interface ${iface}:`, e);
+              }
+            }
+            if (found) {
+              return { rx: maxRx, tx: maxTx };
+            } else {
+              return { rx: 0, tx: 0 };
+            }
+          } catch (ifconfigError) {
+            logger.debug("ifconfig fallback failed:", ifconfigError);
+            return { rx: 0, tx: 0 };
+          }
+        }
+      } else {
+        try {
+          const netstatOutput = await runCommand("cat /proc/net/dev | grep -E '^(eth|wlan|lo|en|wl|ens|eno|enp)' | tail -n +2");
+          let totalRx = 0;
+          let totalTx = 0;
+          const lines = netstatOutput.split("\n").filter((line) => line.trim());
+          for (const line of lines) {
+            const parts = line.split(/\s+/).filter((part) => part.trim());
+            if (parts.length >= 17) {
+              const rx = parseInt(parts[1]) || 0;
+              const tx = parseInt(parts[9]) || 0;
+              totalRx += rx;
+              totalTx += tx;
+            }
+          }
+          if (totalRx > 0 || totalTx > 0) {
+            return { rx: totalRx, tx: totalTx };
+          } else {
+            throw new Error("/proc/net/dev\uC5D0\uC11C \uC720\uD6A8\uD55C \uB370\uC774\uD130\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+          }
+        } catch (error) {
+          logger.debug("/proc/net/dev failed, trying netstat:", error);
+          try {
+            const netstatOutput = await runCommand("netstat -i | grep -E '^(eth|wlan|lo|en|wl|ens|eno|enp)' | tail -n +2");
+            let totalRx = 0;
+            let totalTx = 0;
+            const lines = netstatOutput.split("\n").filter((line) => line.trim());
+            for (const line of lines) {
+              const parts = line.split(/\s+/).filter((part) => part.trim());
+              if (parts.length >= 4) {
+                const rx = parseInt(parts[3]) || 0;
+                const tx = parseInt(parts[7]) || 0;
+                totalRx += rx * 1500;
+                totalTx += tx * 1500;
+              }
+            }
+            if (totalRx > 0 || totalTx > 0) {
+              return { rx: totalRx, tx: totalTx };
+            } else {
+              throw new Error("netstat\uC5D0\uC11C \uC720\uD6A8\uD55C \uB370\uC774\uD130\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+            }
+          } catch (netstatError) {
+            logger.debug("netstat fallback failed:", netstatError);
+            try {
+              const ssOutput = await runCommand("ss -i | grep -c ESTAB");
+              const connections2 = parseInt(ssOutput.trim()) || 0;
+              const estimatedBytes = connections2 * 1024;
+              return { rx: estimatedBytes, tx: estimatedBytes };
+            } catch (ssError) {
+              logger.debug("ss fallback failed:", ssError);
+              try {
+                const sockstatOutput = await runCommand("cat /proc/net/sockstat | grep TCP");
+                const match = sockstatOutput.match(/TCP:\s+(\d+)/);
+                if (match) {
+                  const tcpSockets = parseInt(match[1]) || 0;
+                  const estimatedBytes = tcpSockets * 512;
+                  return { rx: estimatedBytes, tx: estimatedBytes };
+                } else {
+                  throw new Error("/proc/net/sockstat\uC5D0\uC11C TCP \uC815\uBCF4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+                }
+              } catch (sockstatError) {
+                logger.debug("/proc/net/sockstat fallback failed:", sockstatError);
+                return { rx: 0, tx: 0 };
+              }
+            }
+          }
+        }
+      }
+    };
+    const systemStats1 = await getNetworkStats();
+    const processStats1 = await getProcessNetworkStats();
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    const systemStats2 = await getNetworkStats();
+    const processStats2 = await getProcessNetworkStats();
+    const systemRxRate = Math.max(0, systemStats2.rx - systemStats1.rx);
+    const systemTxRate = Math.max(0, systemStats2.tx - systemStats1.tx);
+    const processRxRate = Math.max(0, processStats2.rx - processStats1.rx);
+    const processTxRate = Math.max(0, processStats2.tx - processStats1.tx);
+    const connections = parseInt(connectionsOutput) || 0;
+    const result = {
+      rxRate: formatBytesPerSec(systemRxRate),
+      txRate: formatBytesPerSec(systemTxRate),
+      processRxRate: formatBytesPerSec(processRxRate),
+      processTxRate: formatBytesPerSec(processTxRate),
+      connections,
+      processConnections: processConnectionsCount
+    };
+    return result;
+  } catch (error) {
+    logger.error("Network info fetch error:", error);
+    throw error;
+  }
+}
+
+export {
+  getNetworkInfo
+};

package/dist/chunk-6C7HQIX4.js

@@ -0,0 +1,13 @@
+// src/error/logging/types.ts
+var ELogLevel = /* @__PURE__ */ ((ELogLevel2) => {
+  ELogLevel2["DEBUG"] = "debug";
+  ELogLevel2["INFO"] = "info";
+  ELogLevel2["WARN"] = "warn";
+  ELogLevel2["ERROR"] = "error";
+  ELogLevel2["CRITICAL"] = "critical";
+  return ELogLevel2;
+})(ELogLevel || {});
+
+export {
+  ELogLevel
+};

package/dist/chunk-6D3HHYER.js

@@ -0,0 +1,32 @@
+// src/auth/types/index.ts
+var UserRole = /* @__PURE__ */ ((UserRole2) => {
+  UserRole2["USER"] = "USER";
+  UserRole2["ADMIN"] = "ADMIN";
+  return UserRole2;
+})(UserRole || {});
+var OAuthProvider = /* @__PURE__ */ ((OAuthProvider2) => {
+  OAuthProvider2["GOOGLE"] = "google";
+  OAuthProvider2["GITHUB"] = "github";
+  return OAuthProvider2;
+})(OAuthProvider || {});
+var PasswordStrength = /* @__PURE__ */ ((PasswordStrength2) => {
+  PasswordStrength2["VERY_WEAK"] = "VERY_WEAK";
+  PasswordStrength2["WEAK"] = "WEAK";
+  PasswordStrength2["MEDIUM"] = "MEDIUM";
+  PasswordStrength2["STRONG"] = "STRONG";
+  PasswordStrength2["VERY_STRONG"] = "VERY_STRONG";
+  return PasswordStrength2;
+})(PasswordStrength || {});
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2["EMAIL_VERIFICATION"] = "EMAIL_VERIFICATION";
+  TokenType2["PASSWORD_RESET"] = "PASSWORD_RESET";
+  TokenType2["MAGIC_LINK"] = "MAGIC_LINK";
+  return TokenType2;
+})(TokenType || {});
+
+export {
+  UserRole,
+  OAuthProvider,
+  PasswordStrength,
+  TokenType
+};

package/dist/chunk-6LTZCXNC.js

@@ -0,0 +1,326 @@
+import {
+  getCacheFallbackConfig,
+  getConfig,
+  getEnv,
+  isCacheEnabled,
+  validateRedisEnvironment
+} from "./chunk-I47QEDTX.js";
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/cache/cache-redis.ts
+import { Redis } from "@upstash/redis";
+function getGlobalRedisState() {
+  if (!globalThis.__globalRedisState) {
+    globalThis.__globalRedisState = {
+      isDisabled: false,
+      errorCount: 0,
+      lastErrorTime: null,
+      lastErrorMessage: null,
+      reconnectTimerId: null
+    };
+  }
+  return globalThis.__globalRedisState;
+}
+function getRedisErrorThreshold() {
+  return getCacheFallbackConfig().redisErrorThresholdGlobal;
+}
+function getRedisReconnectInterval() {
+  return getCacheFallbackConfig().redisReconnectInterval;
+}
+function isRedisGloballyDisabled() {
+  return getGlobalRedisState().isDisabled;
+}
+function notifyRedisError(error, source) {
+  const state = getGlobalRedisState();
+  state.errorCount++;
+  state.lastErrorTime = /* @__PURE__ */ new Date();
+  state.lastErrorMessage = error.message;
+  const threshold = getRedisErrorThreshold();
+  logger.warn("[Redis:Global] Redis error occurred", {
+    source,
+    errorCount: state.errorCount,
+    threshold,
+    error: error.message
+  });
+  if (state.errorCount >= threshold && !state.isDisabled) {
+    disableRedisGlobally();
+  }
+}
+function disableRedisGlobally() {
+  const state = getGlobalRedisState();
+  if (state.isDisabled) {
+    return;
+  }
+  state.isDisabled = true;
+  const reconnectInterval = getRedisReconnectInterval();
+  logger.warn("[Redis:Global] Redis globally disabled, falling back to in-memory cache", {
+    errorCount: state.errorCount,
+    lastError: state.lastErrorMessage,
+    reconnectIn: `${reconnectInterval}ms`
+  });
+  if (state.reconnectTimerId) {
+    clearTimeout(state.reconnectTimerId);
+  }
+  state.reconnectTimerId = setTimeout(() => {
+    tryReconnectRedisGlobally();
+  }, reconnectInterval);
+}
+async function tryReconnectRedisGlobally() {
+  const state = getGlobalRedisState();
+  logger.info("[Redis:Global] Attempting Redis reconnection...");
+  try {
+    const env = getEnv();
+    if (!env.UPSTASH_REDIS_REST_URL || !env.UPSTASH_REDIS_REST_TOKEN) {
+      scheduleNextReconnect();
+      return;
+    }
+    const redis = new Redis({
+      url: env.UPSTASH_REDIS_REST_URL,
+      token: env.UPSTASH_REDIS_REST_TOKEN
+    });
+    const pingResult = await redis.ping();
+    if (pingResult === "PONG") {
+      resetRedisGlobalState();
+      logger.info("[Redis:Global] Redis reconnection successful");
+    } else {
+      scheduleNextReconnect();
+    }
+  } catch (error) {
+    logger.warn("[Redis:Global] Redis reconnection failed", {
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
+    scheduleNextReconnect();
+  }
+}
+function scheduleNextReconnect() {
+  const state = getGlobalRedisState();
+  if (state.reconnectTimerId) {
+    clearTimeout(state.reconnectTimerId);
+  }
+  state.reconnectTimerId = setTimeout(() => {
+    tryReconnectRedisGlobally();
+  }, getRedisReconnectInterval());
+}
+function resetRedisGlobalState() {
+  const state = getGlobalRedisState();
+  if (state.errorCount > 0 || state.isDisabled) {
+    logger.info("[Redis:Global] Redis global state reset", {
+      previousErrorCount: state.errorCount,
+      wasDisabled: state.isDisabled
+    });
+  }
+  state.isDisabled = false;
+  state.errorCount = 0;
+  state.lastErrorTime = null;
+  state.lastErrorMessage = null;
+  if (state.reconnectTimerId) {
+    clearTimeout(state.reconnectTimerId);
+    state.reconnectTimerId = null;
+  }
+}
+function getRedisGlobalStatus() {
+  const state = getGlobalRedisState();
+  return {
+    isDisabled: state.isDisabled,
+    errorCount: state.errorCount,
+    lastErrorTime: state.lastErrorTime,
+    lastErrorMessage: state.lastErrorMessage
+  };
+}
+async function checkRedisConnection() {
+  var _a;
+  const startTime = Date.now();
+  try {
+    if (!isCacheEnabled()) {
+      logger.info("[Redis:Cache] Redis connection check skipped: CACHE_ENABLED=false", {
+        purpose: "cache"
+      });
+      return {
+        success: false,
+        error: "Redis cache is disabled (CACHE_ENABLED=false)",
+        details: {
+          purpose: "cache",
+          reason: "CACHE_ENABLED=false",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+    if (!getConfig().isRedisAvailable()) {
+      logger.info("[Redis:Cache] Redis connection check skipped: CACHE_REDIS_ENABLED=false", {
+        purpose: "cache"
+      });
+      return {
+        success: false,
+        error: "Redis backend is disabled (CACHE_REDIS_ENABLED=false)",
+        details: {
+          purpose: "cache",
+          reason: "CACHE_REDIS_ENABLED=false",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+    const envValidation = validateRedisEnvironment();
+    const env = getEnv();
+    if (!envValidation.isValid) {
+      const error = `Redis environment variable validation failed: ${envValidation.errors.join(", ")}`;
+      logger.error("[Redis:Cache] Redis connection failed: Environment variable validation failed", {
+        purpose: "cache",
+        errors: envValidation.errors,
+        nodeEnv: env.NODE_ENV,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { success: false, error };
+    }
+    logger.info("[Redis:Cache] Redis connection status check started", {
+      purpose: "cache"
+    });
+    const redisUrl = env.UPSTASH_REDIS_REST_URL;
+    const redisToken = env.UPSTASH_REDIS_REST_TOKEN;
+    if (!redisUrl || !redisToken || redisUrl.trim() === "" || redisToken.trim() === "") {
+      const error = "Redis environment variables are not configured.";
+      logger.error("[Redis:Cache] Redis connection failed: Environment variables not set", {
+        purpose: "cache",
+        redisUrl: !!redisUrl,
+        redisToken: !!redisToken,
+        redisUrlLength: (redisUrl == null ? void 0 : redisUrl.length) || 0,
+        redisTokenLength: (redisToken == null ? void 0 : redisToken.length) || 0,
+        nodeEnv: env.NODE_ENV,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { success: false, error };
+    }
+    const redis = new Redis({
+      url: redisUrl,
+      token: redisToken
+    });
+    logger.info("[Redis:Cache] Redis client creation complete", {
+      purpose: "cache",
+      url: redisUrl.substring(0, 50) + "...",
+      tokenLength: redisToken.length
+    });
+    const pingResult = await redis.ping();
+    const responseTime = Date.now() - startTime;
+    if (pingResult === "PONG") {
+      logger.info("[Redis:Cache] Redis connection successful", {
+        purpose: "cache",
+        responseTime: `${responseTime}ms`,
+        pingResult
+      });
+      return {
+        success: true,
+        details: {
+          purpose: "cache",
+          responseTime,
+          pingResult,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } else {
+      const error = `Redis PING response differs from expected: ${pingResult}`;
+      logger.error("[Redis:Cache] Redis connection failed: PING response error", {
+        purpose: "cache",
+        expected: "PONG",
+        received: pingResult,
+        responseTime: `${responseTime}ms`
+      });
+      return { success: false, error };
+    }
+  } catch (error) {
+    const responseTime = Date.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logger.error("[Redis:Cache] Redis connection failed: Exception occurred", {
+      purpose: "cache",
+      error: errorMessage,
+      responseTime: `${responseTime}ms`,
+      stack: error instanceof Error ? error.stack : void 0,
+      nodeEnv: getEnv().NODE_ENV,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      success: false,
+      error: errorMessage,
+      details: {
+        purpose: "cache",
+        responseTime,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        errorType: (_a = error == null ? void 0 : error.constructor) == null ? void 0 : _a.name
+      }
+    };
+  }
+}
+function isRedisAvailableNow() {
+  if (isRedisGloballyDisabled()) {
+    return false;
+  }
+  return isCacheEnabled() && getConfig().isRedisAvailable();
+}
+var _redisClient = null;
+var _redisInitialized = false;
+function getRedisClient() {
+  if (isRedisGloballyDisabled()) {
+    return null;
+  }
+  if (_redisInitialized) {
+    return _redisClient;
+  }
+  _redisInitialized = true;
+  if (!isRedisAvailableNow()) {
+    _redisClient = null;
+    return null;
+  }
+  const env = getEnv();
+  if (!env.UPSTASH_REDIS_REST_URL || !env.UPSTASH_REDIS_REST_TOKEN) {
+    _redisClient = null;
+    return null;
+  }
+  _redisClient = new Redis({
+    url: env.UPSTASH_REDIS_REST_URL,
+    token: env.UPSTASH_REDIS_REST_TOKEN
+  });
+  return _redisClient;
+}
+function logRedisInitialization() {
+  var _a;
+  if (typeof globalThis !== "undefined" && globalThis.__redisCacheInitLogged) {
+    return;
+  }
+  const redis = getRedisClient();
+  const env = getEnv();
+  if (isRedisAvailableNow() && redis) {
+    logger.info("[Redis:Cache] Upstash Redis cache connection initialization complete", {
+      purpose: "cache",
+      url: ((_a = env.UPSTASH_REDIS_REST_URL) == null ? void 0 : _a.substring(0, 50)) + "...",
+      cacheEnabled: isCacheEnabled()
+    });
+  } else if (!isCacheEnabled()) {
+    logger.info("[Redis:Cache] Redis cache disabled (CACHE_ENABLED=false)", {
+      purpose: "cache",
+      cacheEnabled: false,
+      redisUrlSet: !!env.UPSTASH_REDIS_REST_URL,
+      redisTokenSet: !!env.UPSTASH_REDIS_REST_TOKEN
+    });
+  } else {
+    logger.warn("[Redis:Cache] Cache disabled due to missing Redis environment variables", {
+      purpose: "cache",
+      cacheEnabled: isCacheEnabled(),
+      redisUrlSet: !!env.UPSTASH_REDIS_REST_URL,
+      redisTokenSet: !!env.UPSTASH_REDIS_REST_TOKEN
+    });
+  }
+  if (typeof globalThis !== "undefined") {
+    globalThis.__redisCacheInitLogged = true;
+  }
+}
+
+export {
+  isRedisGloballyDisabled,
+  notifyRedisError,
+  resetRedisGlobalState,
+  getRedisGlobalStatus,
+  checkRedisConnection,
+  isRedisAvailableNow,
+  getRedisClient,
+  logRedisInitialization
+};