ralphblaster-agent 0.1.1

package/src/executor/prompt-validator.js

@@ -0,0 +1,51 @@
+const logger = require('../logger');
+
+/**
+ * Validate prompt to prevent injection attacks
+ * @param {string} prompt - Prompt to validate
+ * @throws {Error} If prompt contains dangerous content
+ * @returns {boolean} True if validation passes
+ */
+function validatePrompt(prompt) {
+  if (!prompt || typeof prompt !== 'string') {
+    throw new Error('Prompt must be a non-empty string');
+  }
+
+  // Check prompt length (prevent DoS via massive prompts)
+  const MAX_PROMPT_LENGTH = 500000; // 500KB
+  if (prompt.length > MAX_PROMPT_LENGTH) {
+    throw new Error(`Prompt exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`);
+  }
+
+  // Check for dangerous patterns that could lead to malicious operations
+  const dangerousPatterns = [
+    { pattern: /rm\s+-rf\s+\//i, description: 'dangerous deletion command' },
+    { pattern: /rm\s+-rf\s+~/i, description: 'dangerous home directory deletion' },
+    { pattern: /\/etc\/passwd/i, description: 'system file access' },
+    { pattern: /\/etc\/shadow/i, description: 'password file access' },
+    { pattern: /curl.*\|\s*sh/i, description: 'remote code execution pattern' },
+    { pattern: /wget.*\|\s*sh/i, description: 'remote code execution pattern' },
+    { pattern: /eval\s*\(/i, description: 'code evaluation' },
+    { pattern: /exec\s*\(/i, description: 'code execution' },
+    { pattern: /\$\(.*rm.*-rf/i, description: 'command injection with deletion' },
+    { pattern: /`.*rm.*-rf/i, description: 'command injection with deletion' },
+    { pattern: /base64.*decode.*eval/i, description: 'obfuscated code execution' },
+    { pattern: /\.ssh\/id_rsa/i, description: 'SSH key access' },
+    { pattern: /\.aws\/credentials/i, description: 'AWS credentials access' }
+  ];
+
+  for (const { pattern, description } of dangerousPatterns) {
+    if (pattern.test(prompt)) {
+      logger.error(`Prompt validation failed: contains ${description}`);
+      throw new Error(`Prompt contains potentially dangerous content: ${description}`);
+    }
+  }
+
+  // Log sanitized version for security audit
+  const sanitizedPreview = prompt.substring(0, 200).replace(/\n/g, ' ');
+  logger.debug(`Prompt validated (${prompt.length} chars): ${sanitizedPreview}...`);
+
+  return true;
+}
+
+module.exports = { validatePrompt };

package/src/executor.js

@@ -0,0 +1,4 @@
+// Backwards compatibility wrapper
+// The actual Executor class has been moved to ./executor/index.js
+// This file exists to maintain compatibility with existing imports
+module.exports = require('./executor/index');

package/src/index.js

@@ -0,0 +1,342 @@
+const ApiClient = require('./api-client');
+const Executor = require('./executor');
+const ProgressThrottle = require('./progress-throttle');
+const ErrorWindow = require('./error-window');
+const config = require('./config');
+const loggingConfig = require('./logging/config');
+const logger = require('./logger');
+const { formatDuration } = require('./utils/format');
+
+// Timeout constants
+const TIMEOUTS = {
+  SHUTDOWN_DELAY_MS: 500, // Delay before shutdown
+  ERROR_RETRY_DELAY_MS: 5000, // 5 seconds retry delay after errors
+  HEARTBEAT_INTERVAL_MS: 20000, // 20 seconds for heartbeat
+  MIN_REQUEST_INTERVAL_MS: 1000, // Minimum 1 second between API requests
+};
+
+class RalphAgent {
+  constructor() {
+    // Agent ID for multi-agent support (from centralized logging config)
+    this.agentId = loggingConfig.agentId;
+
+    this.apiClient = new ApiClient(this.agentId);
+    this.executor = new Executor(this.apiClient);
+    this.isRunning = false;
+    this.currentJob = null;
+    this.heartbeatInterval = null;
+    this.jobStartTime = null; // Track when job started for elapsed time
+
+    // Rate limiting state
+    this.lastRequestTime = 0;
+    this.minRequestInterval = TIMEOUTS.MIN_REQUEST_INTERVAL_MS;
+
+    // Time-window based error tracking for circuit breaker
+    this.errorWindow = new ErrorWindow();
+
+    // Adaptive progress throttling
+    this.progressThrottle = new ProgressThrottle();
+  }
+
+  /**
+   * Start the agent
+   */
+  async start() {
+    this.isRunning = true;
+
+    // Set agent ID in logger context
+    logger.setAgentId(this.agentId);
+
+    logger.info('Ralph Agent starting...');
+    logger.info(`Agent ID: ${this.agentId}`);
+    logger.info(`API URL: ${config.apiUrl}`);
+
+    // Setup graceful shutdown
+    this.setupShutdownHandlers();
+
+    // Start polling loop
+    await this.pollLoop();
+  }
+
+  /**
+   * Stop the agent
+   */
+  async stop() {
+    logger.info('Ralph Agent stopping...');
+    this.isRunning = false;
+
+    // Stop heartbeat first to prevent updates during shutdown
+    this.stopHeartbeat();
+
+    // Kill any running Claude process
+    if (this.executor.currentProcess) {
+      logger.warn('Terminating running Claude process');
+      await this.executor.killCurrentProcess();
+    }
+
+    // If currently executing a job, mark it as failed
+    if (this.currentJob) {
+      logger.warn(`Marking job #${this.currentJob.id} as failed due to shutdown`);
+      try {
+        await this.apiClient.markJobFailed(
+          this.currentJob.id,
+          'Agent shutdown during execution'
+        );
+      } catch (error) {
+        logger.error('Failed to mark job as failed during shutdown: ' + error.message);
+      }
+    }
+
+    logger.info('Ralph Agent stopped');
+    // Give async operations time to complete before exiting
+    setTimeout(() => process.exit(0), TIMEOUTS.SHUTDOWN_DELAY_MS);
+  }
+
+  /**
+   * Main polling loop with rate limiting and exponential backoff
+   */
+  async pollLoop() {
+    while (this.isRunning) {
+      try {
+        // Enforce minimum interval between requests
+        const now = Date.now();
+        const timeSinceLastRequest = now - this.lastRequestTime;
+        if (timeSinceLastRequest < this.minRequestInterval) {
+          await this.sleep(this.minRequestInterval - timeSinceLastRequest);
+        }
+        this.lastRequestTime = Date.now();
+
+        // Check for next job (long polling - server waits up to 10s)
+        const job = await this.apiClient.getNextJob();
+
+        // Note: Successful API call (error window handles its own cleanup)
+
+        if (job) {
+          await this.processJob(job);
+          // After processing, immediately poll for next job
+        } else {
+          // No jobs available after long poll timeout
+          // Small delay before reconnecting to prevent hammering
+          await this.sleep(1000); // 1s minimum between polls
+        }
+      } catch (error) {
+        // Record error in time window for circuit breaker
+        this.errorWindow.addError();
+        const errorCount = this.errorWindow.getErrorCount();
+
+        logger.error(`Error in poll loop (${errorCount} errors in last 60s)`, error.message);
+
+        // Exponential backoff based on recent error count: 5s, 10s, 20s, 40s, max 60s
+        const backoffTime = Math.min(
+          TIMEOUTS.ERROR_RETRY_DELAY_MS * Math.pow(2, Math.min(errorCount - 1, 4)),
+          60000
+        );
+
+        logger.info(`Backing off for ${backoffTime}ms before retry`);
+        await this.sleep(backoffTime);
+
+        // Circuit breaker: Stop if error rate exceeds 50% over last 60 seconds
+        if (this.errorWindow.shouldShutdown()) {
+          logger.error('Error rate >50% in last 60 seconds, shutting down for safety');
+          logger.error(`Total errors: ${errorCount} (threshold based on 5s request interval)`);
+          await this.stop();
+        }
+      }
+    }
+  }
+
+  /**
+   * Process a job
+   * @param {Object} job - Job object from API
+   */
+  async processJob(job) {
+    this.currentJob = job;
+    this.jobStartTime = Date.now(); // Track start time for elapsed time calculation
+
+    logger.info('═══════════════════════════════════════════════════════════');
+    logger.info(`Processing Job #${job.id}`, {
+      jobType: job.job_type,
+      taskTitle: job.task_title,
+      projectName: job.project?.name,
+      hasPrompt: !!job.prompt,
+      promptLength: job.prompt?.length || 0
+    });
+    logger.info('═══════════════════════════════════════════════════════════');
+
+    // Set logger context so internal logs are sent to UI (Phase 3: with global context)
+    logger.setJobContext(job.id, this.apiClient, {
+      jobType: job.job_type,
+      taskTitle: job.task_title,
+      projectId: job.project?.id,
+      projectName: job.project?.name
+    });
+
+    try {
+      // Mark job as running
+      logger.debug('Marking job as running...');
+      await this.apiClient.markJobRunning(job.id);
+      logger.debug('Job marked as running in API');
+
+      // Send initial status event
+      logger.debug('Sending initial status event to UI...');
+      await this.apiClient.sendStatusEvent(job.id, 'job_claimed', `Starting: ${job.task_title}`);
+
+      // Start heartbeat to keep job alive
+      logger.debug('Starting heartbeat timer...');
+      this.startHeartbeat(job.id);
+
+      // Reset progress throttle for new job
+      this.progressThrottle = new ProgressThrottle();
+
+      // Execute the job with progress callback
+      logger.info('Beginning job execution...');
+      const result = await this.executor.execute(job, async (chunk) => {
+        // Adaptive throttling: adjusts based on update rate
+        // High rate (>20/sec): 500ms throttle, Medium (5-20/sec): 200ms, Low (<5/sec): 100ms
+        if (this.progressThrottle.shouldThrottle()) {
+          return; // Skip this update
+        }
+
+        // Record this update for rate tracking
+        this.progressThrottle.recordUpdate();
+
+        // Send progress update to server (best-effort, don't fail job on error)
+        try {
+          await this.apiClient.sendProgress(job.id, chunk);
+        } catch (error) {
+          logger.debug(`Progress update failed for job #${job.id}: ${error.message}`);
+        }
+      });
+
+      logger.info('Job execution completed, processing results...');
+
+      // Mark job as completed
+      logger.info('Marking job as completed in API...');
+      await this.apiClient.markJobCompleted(job.id, result);
+
+      const executionTime = Date.now() - this.jobStartTime;
+      logger.info('═══════════════════════════════════════════════════════════');
+      logger.info(`✓ Job #${job.id} completed successfully`, {
+        executionTimeMs: executionTime,
+        executionTime: formatDuration(executionTime)
+      });
+      logger.info('═══════════════════════════════════════════════════════════');
+    } catch (error) {
+      const executionTime = Date.now() - this.jobStartTime;
+      logger.error('═══════════════════════════════════════════════════════════');
+      logger.error(`✗ Job #${job.id} failed after ${formatDuration(executionTime)}`, {
+        error: error.message,
+        category: error.category,
+        hasPartialOutput: !!error.partialOutput
+      });
+      logger.error('═══════════════════════════════════════════════════════════');
+
+      // Mark job as failed (pass full error object to include categorization)
+      logger.info('Marking job as failed in API...');
+      await this.apiClient.markJobFailed(
+        job.id,
+        error,  // Pass full error object instead of just message
+        error.partialOutput || null
+      );
+
+      logger.error(`Job #${job.id} marked as failed in API`);
+    } finally {
+      // Stop heartbeat immediately to prevent race conditions
+      this.stopHeartbeat();
+      logger.info('Heartbeat stopped');
+
+      // Clear logger context (flush remaining batched logs)
+      logger.info('Flushing remaining logs to API...');
+      await logger.clearJobContext();
+      logger.info('Logger context cleared');
+
+      // Clear current job reference and reset time tracking
+      this.currentJob = null;
+      this.jobStartTime = null;
+    }
+  }
+
+
+  /**
+   * Start heartbeat for job
+   * @param {number} jobId - Job ID
+   */
+  startHeartbeat(jobId) {
+    // Send heartbeat every 20 seconds to maintain online status (backend offline threshold: 35s)
+    this.heartbeatInterval = setInterval(async () => {
+      try {
+        // Calculate elapsed time
+        const elapsed = Date.now() - this.jobStartTime;
+        const minutes = Math.floor(elapsed / 60000);
+        const seconds = Math.floor((elapsed % 60000) / 1000);
+
+        // Phase 1.2: Send combined heartbeat + status event in single call (reduces API calls by 50%)
+        await this.apiClient.sendHeartbeat(jobId, {
+          event_type: 'heartbeat',
+          message: `Still working... (${minutes}m ${seconds}s elapsed)`,
+          metadata: { elapsed_ms: elapsed }
+        });
+
+        // REMOVED: Separate sendStatusEvent() call
+        // await this.apiClient.sendStatusEvent(jobId, 'heartbeat', ...);
+      } catch (err) {
+        logger.warn('Heartbeat failed: ' + err.message);
+      }
+    }, TIMEOUTS.HEARTBEAT_INTERVAL_MS);
+  }
+
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   */
+  setupShutdownHandlers() {
+    process.on('SIGINT', () => {
+      logger.info('Received SIGINT signal');
+      this.stop();
+    });
+
+    process.on('SIGTERM', () => {
+      logger.info('Received SIGTERM signal');
+      this.stop();
+    });
+
+    process.on('uncaughtException', (error) => {
+      logger.error('╔══════════════════════════════════════════════════════════');
+      logger.error('║ UNCAUGHT EXCEPTION - Agent will shutdown');
+      logger.error('║ Message: ' + (error?.message || error));
+      logger.error('║ Stack: ' + (error?.stack || 'no stack'));
+      logger.error('╚══════════════════════════════════════════════════════════');
+      console.error('UNCAUGHT EXCEPTION:', error);
+      this.stop();
+    });
+
+    process.on('unhandledRejection', (reason, promise) => {
+      logger.error('╔══════════════════════════════════════════════════════════');
+      logger.error('║ UNHANDLED REJECTION - Agent will shutdown');
+      logger.error('║ Reason: ' + (reason?.message || reason));
+      logger.error('║ Stack: ' + (reason?.stack || 'no stack'));
+      logger.error('╚══════════════════════════════════════════════════════════');
+      console.error('UNHANDLED REJECTION:', reason);
+      this.stop();
+    });
+  }
+
+  /**
+   * Sleep helper
+   * @param {number} ms - Milliseconds to sleep
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = RalphAgent;

package/src/logger.js

@@ -0,0 +1,193 @@
+const loggingConfig = require('./logging/config');
+const LogManager = require('./logging/log-manager');
+const { ConsoleDestination } = require('./logging/destinations');
+
+// Create console destination with centralized config
+const consoleDestination = new ConsoleDestination({
+  colors: loggingConfig.consoleColors,
+  format: loggingConfig.consoleFormat,
+  minLevel: loggingConfig.logLevel
+});
+
+// Initialize LogManager with console destination
+// API destination will be added dynamically when job context is set
+const logManager = new LogManager([consoleDestination], {
+  agentId: loggingConfig.agentId
+});
+
+/**
+ * Internal log function that delegates to LogManager
+ * @param {string} level - Log level ('error', 'warn', 'info', 'debug')
+ * @param {string} message - Log message to output
+ * @param {Object|null} data - Optional structured metadata to include
+ * @private
+ */
+function log(level, message, data = null) {
+  // Delegate to LogManager (non-blocking)
+  logManager[level](message, data || {}).catch(() => {
+    // Silently handle errors to prevent cascading failures
+  });
+
+  // For error level, trigger immediate flush
+  if (level === 'error') {
+    logManager.flush().catch(() => {}); // Best-effort immediate flush
+  }
+}
+
+module.exports = {
+  /**
+   * Log an error message (level 0 - always visible)
+   * Used for critical errors requiring immediate attention.
+   * Sent to API if job context is set, and flushed immediately (doesn't wait for batch).
+   * @param {string} msg - Error message
+   * @param {Object} [data] - Optional structured metadata
+   * @example
+   *   logger.error('Database connection failed', { error: err.message })
+   */
+  error: (msg, data) => log('error', msg, data),
+
+  /**
+   * Log a warning message (level 1)
+   * Used for concerning conditions that should be reviewed but aren't critical.
+   * Warning logs are NOT sent to the API (local only).
+   * @param {string} msg - Warning message
+   * @param {Object} [data] - Optional structured metadata
+   * @example
+   *   logger.warn('Disk space low', { available: '5%' })
+   */
+  warn: (msg, data) => log('warn', msg, data),
+
+  /**
+   * Log an info message (level 2 - default)
+   * Used for general operational information.
+   * Sent to API if job context is set.
+   * @param {string} msg - Info message
+   * @param {Object} [data] - Optional structured metadata
+   * @example
+   *   logger.info('Server started', { port: 3000 })
+   */
+  info: (msg, data) => log('info', msg, data),
+
+  /**
+   * Log a debug message (level 3 - most verbose)
+   * Used for detailed debugging information.
+   * Debug logs are NOT sent to the API (local only).
+   * @param {string} msg - Debug message
+   * @param {Object} [data] - Optional structured metadata
+   * @example
+   *   logger.debug('Request received', { headers, body })
+   */
+  debug: (msg, data) => log('debug', msg, data),
+
+  /**
+   * Set agent ID for multi-agent support
+   * @param {string} id - Agent ID (e.g., 'agent-1', 'agent-2')
+   */
+  setAgentId: (id) => {
+    logManager.setAgentId(id);
+  },
+
+  /**
+   * Set job context for API logging
+   * When set, info and error logs will be sent to the API's "Instance Setup Logs"
+   * Uses batching to reduce API overhead (flushes every 2s or when 10 logs buffered)
+   * @param {number} jobId - Job ID
+   * @param {Object} apiClient - API client instance
+   * @param {Object} context - Optional global context to add to all logs
+   */
+  setJobContext: (jobId, apiClient, context = {}) => {
+    // Set job context in LogManager
+    logManager.setJobContext(jobId, context);
+  },
+
+  /**
+   * Clear job context (called when job completes)
+   * Ensures all buffered logs are flushed before shutdown
+   */
+  clearJobContext: async () => {
+    // Clear job context in LogManager
+    await logManager.clearJobContext();
+  },
+
+  // ===== Phase 3: Enhanced Structured Logging =====
+
+  /**
+   * Set global context that will be included in all subsequent logs
+   * @param {string|Object} keyOrContext - Key name or object with multiple keys
+   * @param {*} value - Value (only if first param is a string)
+   * @example
+   *   logger.setContext('component', 'worktree')
+   *   logger.setContext({ component: 'worktree', operation: 'create' })
+   */
+  setContext: (keyOrContext, value) => {
+    logManager.setContext(keyOrContext, value);
+  },
+
+  /**
+   * Create a child logger with additional context
+   * Context is additive - child inherits parent context and adds its own
+   * @param {Object} context - Additional context for this child logger
+   * @returns {Object} Child logger with all parent methods
+   * @example
+   *   const worktreeLogger = logger.child({ component: 'worktree' })
+   *   worktreeLogger.info('Creating worktree') // Includes component: 'worktree'
+   */
+  child: (context) => {
+    return logManager.child(context);
+  },
+
+  /**
+   * Log a semantic event with structured metadata
+   * @param {string} eventType - Event type in format 'category.action' (e.g., 'worktree.created')
+   * @param {Object} data - Additional event data
+   * @example
+   *   logger.event('worktree.created', { path: '/path/to/worktree', duration: 3200 })
+   */
+  event: (eventType, data = {}) => {
+    logManager.event(eventType, data).catch(() => {
+      // Silently handle errors to prevent cascading failures
+    });
+  },
+
+  /**
+   * Start a performance timer for an operation
+   * @param {string} operation - Operation name (e.g., 'worktree.create')
+   * @param {Object} initialContext - Initial context for the operation
+   * @returns {Object} Timer object with done() method
+   * @example
+   *   const timer = logger.startTimer('worktree.create')
+   *   // ... do work ...
+   *   timer.done({ path: '/path/to/worktree' }) // Logs duration automatically
+   */
+  startTimer: (operation, initialContext = {}) => {
+    return logManager.startTimer(operation, initialContext);
+  },
+
+  /**
+   * Measure and log an async operation automatically
+   * @param {string} operation - Operation name (e.g., 'prd.conversion')
+   * @param {Function} fn - Async function to measure
+   * @param {Object} context - Additional context
+   * @returns {Promise<*>} Result of the async function
+   * @example
+   *   const result = await logger.measure('prd.conversion', async () => {
+   *     return await convertPRD(job)
+   *   })
+   *   // Logs: prd.conversion.started, then prd.conversion.complete with duration
+   */
+  measure: async (operation, fn, context = {}) => {
+    return await logManager.measure(operation, fn, context);
+  },
+
+  // ===== Direct Access to LogManager =====
+
+  /**
+   * Get the underlying LogManager instance
+   * Useful for advanced use cases like adding/removing destinations dynamically
+   * @returns {LogManager} The LogManager instance
+   * @example
+   *   const manager = logger.getManager()
+   *   manager.addDestination(new FileDestination({ path: '/var/log/app.log' }))
+   */
+  getManager: () => logManager
+};

package/src/logging/README.md

@@ -0,0 +1,93 @@
+# Logging Configuration
+
+This directory contains centralized logging configuration for the RalphBlaster Agent.
+
+## Files
+
+### `config.js`
+
+Central configuration module that consolidates all logging-related settings:
+
+- **Console Output Settings**: `logLevel`, `consoleColors`, `consoleFormat`
+- **Log Batching Settings**: `maxBatchSize`, `flushInterval`, `useBatchEndpoint`
+- **Agent Identification**: `agentId`
+
+All settings are read from environment variables with sensible defaults and validation.
+
+### `formatter.js`
+
+Shared formatting utilities for log output:
+
+- Message formatting and redaction
+- Metadata formatting
+- Color codes and styling
+
+## Usage
+
+### Importing Configuration
+
+```javascript
+const loggingConfig = require('./logging/config');
+
+console.log(loggingConfig.logLevel);        // 'info'
+console.log(loggingConfig.consoleColors);   // true
+console.log(loggingConfig.maxBatchSize);    // 10
+```
+
+### Environment Variables
+
+| Variable | Type | Default | Description |
+|----------|------|---------|-------------|
+| `RALPHBLASTER_LOG_LEVEL` | string | `info` | Log level: error, warn, info, debug |
+| `RALPHBLASTER_CONSOLE_COLORS` | boolean | `true` | Enable/disable colored output |
+| `RALPHBLASTER_CONSOLE_FORMAT` | string | `pretty` | Console format: pretty, json |
+| `RALPHBLASTER_AGENT_ID` | string | `agent-default` | Agent identifier for multi-agent mode |
+| `RALPHBLASTER_MAX_BATCH_SIZE` | number | `10` | Max logs to batch before flush |
+| `RALPHBLASTER_FLUSH_INTERVAL` | number | `2000` | Milliseconds between auto-flushes |
+| `RALPHBLASTER_USE_BATCH_ENDPOINT` | boolean | `true` | Use batch API endpoint |
+
+### Validation
+
+The configuration module validates all values:
+
+- **Log Level**: Must be one of `error`, `warn`, `info`, `debug` (falls back to `info`)
+- **Console Format**: Must be one of `pretty`, `json` (falls back to `pretty`)
+- **Numeric Values**: Must be positive integers (falls back to defaults)
+- **Boolean Values**: Treats `false`, `0`, and empty string as false
+
+Invalid values trigger a warning and use the default value.
+
+### Immutability
+
+The configuration object is frozen to prevent accidental modifications:
+
+```javascript
+loggingConfig.logLevel = 'debug'; // Fails silently in non-strict mode
+console.log(loggingConfig.logLevel); // Still 'info'
+```
+
+## Migration Notes
+
+Previously, logging settings were scattered across multiple files:
+
+- `src/config.js` - logLevel, consoleColors, consoleFormat
+- `src/setup-log-batcher.js` - maxBatchSize, flushInterval, useBatchEndpoint
+- `src/index.js` - agentId
+
+Now all settings are centralized in `src/logging/config.js`.
+
+### Backward Compatibility
+
+For backward compatibility, `src/config.js` re-exports the console-related settings:
+
+```javascript
+const config = require('./config');
+console.log(config.logLevel); // Still works
+```
+
+However, new code should import directly from `logging/config`:
+
+```javascript
+const loggingConfig = require('./logging/config');
+console.log(loggingConfig.logLevel); // Preferred
+```