Logging & Console

interface Logger {
  /** Disables all logging output */
  disable(): void;
  /** Enables logging output */
  enable(): void;
  /** Logs informational messages */
  log(...args: any[]): void;
  /** Logs warning messages */
  warn(...args: any[]): void;
  /** Logs error messages */
  error(...args: any[]): void;
  /** Logs debug messages (when debug level enabled) */
  debug(...args: any[]): void;
}

/**
 * Global logger instance used throughout Sentry SDKs
 */
declare const logger: Logger;

import { logger } from "@sentry/core";

// Basic logging
logger.log('Processing user data...');
logger.warn('Deprecated API usage detected');
logger.error('Failed to send event to Sentry');
logger.debug('Detailed debugging information');

// Conditional logging
function processData(data: any) {
  logger.log('Starting data processing');
  
  try {
    // Process data
    const result = transformData(data);
    logger.log('Data processing completed successfully');
    return result;
  } catch (error) {
    logger.error('Data processing failed:', error);
    throw error;
  }
}

// Disable logging in production
if (process.env.NODE_ENV === 'production') {
  logger.disable();
}

/**
 * Array of available console log levels in priority order
 */
declare const CONSOLE_LEVELS: readonly [
  'debug',
  'info', 
  'warn',
  'error',
  'log',
  'assert',
  'trace'
];

import { CONSOLE_LEVELS } from "@sentry/core";

// Iterate through all console levels
CONSOLE_LEVELS.forEach(level => {
  console.log(`Console level: ${level}`);
});

// Check if a level is valid
function isValidConsoleLevel(level: string): level is typeof CONSOLE_LEVELS[number] {
  return CONSOLE_LEVELS.includes(level as any);
}

/**
 * Executes a callback with console methods temporarily replaced/modified
 * @param callback - Function to execute within the console sandbox
 * @returns Result of the callback function
 */
function consoleSandbox<T>(callback: () => T): T;

import { consoleSandbox } from "@sentry/core";

// Execute code without console output
const result = consoleSandbox(() => {
  console.log('This will not appear in console');
  console.warn('Neither will this');
  return performCalculation();
});

// Custom console behavior during testing
function runSilentTest() {
  const logs: string[] = [];
  
  const testResult = consoleSandbox(() => {
    // Temporarily capture console output instead of displaying it
    const originalLog = console.log;
    console.log = (...args) => {
      logs.push(args.join(' '));
    };
    
    try {
      return runTestSuite();
    } finally {
      console.log = originalLog;
    }
  });
  
  return { result: testResult, capturedLogs: logs };
}

/**
 * Object containing references to original console methods before instrumentation
 */
declare const originalConsoleMethods: {
  /** Original console.log method */
  log: (...args: any[]) => void;
  /** Original console.warn method */
  warn: (...args: any[]) => void;
  /** Original console.error method */
  error: (...args: any[]) => void;
  /** Original console.debug method */
  debug: (...args: any[]) => void;
  /** Original console.info method */
  info: (...args: any[]) => void;
  /** Original console.trace method */
  trace: (...args: any[]) => void;
  /** Original console.assert method */
  assert: (condition?: boolean, ...data: any[]) => void;
};

import { originalConsoleMethods } from "@sentry/core";

// Always use original console methods, bypassing any instrumentation
function criticalErrorLogger(message: string, error: Error) {
  // This will always output to console even if console is instrumented
  originalConsoleMethods.error('CRITICAL ERROR:', message, error);
}

// Restore original console methods
function restoreConsole() {
  console.log = originalConsoleMethods.log;
  console.warn = originalConsoleMethods.warn;
  console.error = originalConsoleMethods.error;
  console.debug = originalConsoleMethods.debug;
}

// Compare instrumented vs original behavior
function debugConsoleInstrumentation() {
  console.log('This goes through instrumentation');
  originalConsoleMethods.log('This bypasses instrumentation');
}

import { logger } from "@sentry/core";

interface LogContext {
  userId?: string;
  requestId?: string;
  component: string;
  action: string;
}

class StructuredLogger {
  constructor(private context: LogContext) {}
  
  info(message: string, data?: any) {
    logger.log(JSON.stringify({
      level: 'info',
      message,
      context: this.context,
      data,
      timestamp: new Date().toISOString()
    }));
  }
  
  warn(message: string, data?: any) {
    logger.warn(JSON.stringify({
      level: 'warn',
      message,
      context: this.context,
      data,
      timestamp: new Date().toISOString()
    }));
  }
  
  error(message: string, error?: Error) {
    logger.error(JSON.stringify({
      level: 'error',
      message,
      context: this.context,
      error: error ? {
        name: error.name,
        message: error.message,
        stack: error.stack
      } : undefined,
      timestamp: new Date().toISOString()
    }));
  }
}

// Usage
const apiLogger = new StructuredLogger({
  component: 'api',
  action: 'user-creation'
});

apiLogger.info('Creating new user', { email: 'user@example.com' });

import { logger } from "@sentry/core";

class DevelopmentLogger {
  private isDevelopment = process.env.NODE_ENV === 'development';
  
  dev(message: string, ...args: any[]) {
    if (this.isDevelopment) {
      logger.log(`[DEV] ${message}`, ...args);
    }
  }
  
  devWarn(message: string, ...args: any[]) {
    if (this.isDevelopment) {
      logger.warn(`[DEV] ${message}`, ...args);
    }
  }
  
  devError(message: string, ...args: any[]) {
    if (this.isDevelopment) {
      logger.error(`[DEV] ${message}`, ...args);
    }
  }
}

const devLogger = new DevelopmentLogger();

// These only log in development
devLogger.dev('User state changed', userState);
devLogger.devWarn('Performance warning: slow query detected');

import { originalConsoleMethods, consoleSandbox } from "@sentry/core";

class ConsoleInterceptor {
  private interceptedLogs: Array<{
    level: string;
    args: any[];
    timestamp: Date;
  }> = [];
  
  startInterception() {
    // Store original methods
    const originalLog = console.log;
    const originalWarn = console.warn;
    const originalError = console.error;
    
    // Replace with intercepting versions
    console.log = (...args) => {
      this.interceptedLogs.push({
        level: 'log',
        args,
        timestamp: new Date()
      });
      originalLog.apply(console, args);
    };
    
    console.warn = (...args) => {
      this.interceptedLogs.push({
        level: 'warn',
        args,
        timestamp: new Date()
      });
      originalWarn.apply(console, args);
    };
    
    console.error = (...args) => {
      this.interceptedLogs.push({
        level: 'error',
        args,
        timestamp: new Date()
      });
      originalError.apply(console, args);
    };
  }
  
  stopInterception() {
    console.log = originalConsoleMethods.log;
    console.warn = originalConsoleMethods.warn;
    console.error = originalConsoleMethods.error;
  }
  
  getInterceptedLogs() {
    return this.interceptedLogs.slice(); // Return copy
  }
  
  clearLogs() {
    this.interceptedLogs.length = 0;
  }
}

import { consoleSandbox, originalConsoleMethods } from "@sentry/core";

function executeSilently<T>(fn: () => T): T {
  return consoleSandbox(() => {
    // Temporarily silence all console output
    const noop = () => {};
    console.log = noop;
    console.warn = noop;
    console.error = noop;
    console.debug = noop;
    console.info = noop;
    
    try {
      return fn();
    } finally {
      // Console methods are automatically restored by consoleSandbox
    }
  });
}

// Usage
const result = executeSilently(() => {
  console.log('This will not appear');
  return performCalculation();
});

import { logger } from "@sentry/core";

function configureLogger() {
  const env = process.env.NODE_ENV;
  const logLevel = process.env.LOG_LEVEL;
  
  switch (env) {
    case 'production':
      // Minimal logging in production
      if (logLevel !== 'debug') {
        logger.disable();
      }
      break;
      
    case 'test':
      // Silent during tests unless explicitly enabled
      if (!process.env.ENABLE_TEST_LOGS) {
        logger.disable();
      }
      break;
      
    case 'development':
    default:
      // Full logging in development
      logger.enable();
      break;
  }
}

// Initialize logging configuration
configureLogger();