DoubleTie Logger Troubleshooting

// This will only show error logs
const logger = createLogger({ level: 'error' });
logger.info('This won't appear'); // Lower priority than error
logger.debug('This won't appear either'); // Lower priority than error

// Show all logs in development
const logger = createLogger({ level: 'debug' });
 
// Or dynamically configure it
const logger = createLogger({ 
  level: process.env.NODE_ENV === 'production' ? 'error' : 'debug' 
});

// No logs will appear with this configuration
const logger = createLogger({ disabled: true });

const logger = createLogger({ 
  disabled: process.env.DISABLE_LOGGING === 'true',
  level: 'info'
});

// This handler never actually outputs anything
const badHandler = (level, message) => {
  // Doesn't do anything with the message
};
 
// Fix: Actually log the message
const goodHandler = (level, message, ...args) => {
  console.log(`[${level.toUpperCase()}] ${message}`, ...args);
};

// Import the types you need
import type { Logger, LoggerOptions, LogLevel } from '@doubletie/logger';
 
// Use the types in your code
const options: LoggerOptions = {
  level: 'info' as LogLevel,
  appName: 'my-app'
};
 
const logger: Logger = createLogger(options);

import { createLogger, extendLogger } from '@doubletie/logger';
import type { Logger, LoggerExtensions } from '@doubletie/logger';
 
// Create your extension interface
interface HttpLoggerExtensions extends LoggerExtensions {
  request: (method: string, url: string) => void;
  response: (status: number, body: unknown) => void;
}
 
// Create the extended logger
const httpLogger = extendLogger<HttpLoggerExtensions>(
  createLogger(),
  {
    request: (method, url) => logger.info(`${method} ${url}`),
    response: (status, body) => logger.debug('Response', { status, body })
  }
);
 
// TypeScript now knows about your custom methods
httpLogger.request('GET', '/api/users');

// This will cause problems in logs
const user = { name: 'John' };
const manager = { name: 'Alice', reports: [] };
 
// Circular reference
user.manager = manager;
manager.reports.push(user);
 
// This will cause a circular reference error
logger.debug('User structure', { user });

import { createLogger } from '@doubletie/logger';
 
// Create a function to handle circular references
function sanitizeForLogs(obj) {
  const cache = new Set();
  return JSON.parse(JSON.stringify(obj, (key, value) => {
    if (typeof value === 'object' && value !== null) {
      if (cache.has(value)) {
        return '[Circular Reference]';
      }
      cache.add(value);
    }
    return value;
  }));
}
 
// Use it when logging
logger.debug('User structure', sanitizeForLogs({ user }));

// This might fail if called too early
import { redirectNextjsLogger } from '@doubletie/logger';
redirectNextjsLogger();  // Next.js logger might not be initialized yet

import { createLogger, redirectNextjsLogger } from '@doubletie/logger';
 
const logger = createLogger();
 
// Try to redirect, and if it fails, retry after a delay
let success = redirectNextjsLogger(logger);
 
if (!success && typeof window !== 'undefined') {
  // In the browser, retry after Next.js has had time to initialize
  setTimeout(() => {
    redirectNextjsLogger(logger);
  }, 1000);
}

// lib/logger.ts
import { createLogger, redirectAllLoggers } from '@doubletie/logger';
 
const logger = createLogger();
 
// This will work differently in client vs server contexts
redirectAllLoggers(logger);

// lib/logger.ts
import { createLogger, redirectAllLoggers } from '@doubletie/logger';
 
const logger = createLogger();
 
// For client-side only
if (typeof window !== 'undefined') {
  // Only redirect in the browser
  redirectAllLoggers(logger);
}
 
// For server-side, export a function to be called when needed
export function setupServerLogger() {
  redirectAllLoggers(logger);
  return logger;
}
 
export default logger;

// Register a custom formatter
registerFormatter('custom', myCustomFormatter);
 
// But it doesn't seem to be used
const logger = createLogger();
logger.info('Test message');  // Uses default formatter

// Register a custom formatter
registerFormatter('custom', myCustomFormatter);
 
// Specify it when creating the logger
const logger = createLogger({
  formatter: 'custom'
});

const logger = createLogger({
  level: process.env.NODE_ENV === 'production' ? 'error' : 'debug',
});

// BAD: This always calculates the expensive data, even if not logged
logger.debug('System status', calculateExpensiveMetrics());
 
// GOOD: Only calculate if actually being logged
if (logger.isLevelEnabled('debug')) {
  logger.debug('System status', calculateExpensiveMetrics());
}

// Create a special high-performance logger for critical paths
const criticalPathLogger = createLogger({
  disabled: process.env.NODE_ENV === 'production',
  level: 'error'
});
 
// Use it in performance-critical code
function highPerformanceOperation() {
  criticalPathLogger.debug('Starting operation'); // No-op in production
  // Critical code
}

import { err, ok, Result } from 'neverthrow';
import { logResult, createLogger } from '@doubletie/logger';
import type { LoggableError } from '@doubletie/logger';
 
// Ensure error object satisfies LoggableError interface
interface MyError extends LoggableError {
  message: string; // Required
  code: string;    // Optional but useful
  details?: any;   // Any additional fields
}
 
function validate(): Result<string, MyError> {
  // Implementation...
}
 
// Now this will work correctly
const result = logResult(validate(), logger);

// This won't work as expected
const promise = fetchData().then(result => {
  return logResult(result, logger); // result is not a Result, it's the unwrapped value!
});
 
// Fix: Use logResultAsync for ResultAsync
import { logResultAsync } from '@doubletie/logger';
 
const resultAsync = logResultAsync(fetchDataAsync(), logger);