Jassif Team Institution

// Basic logging
console.log('Info message');
console.error('Error message');
console.warn('Warning message');
console.debug('Debug message');

// Log objects
const user = { id: 1, name: 'John', roles: ['admin', 'user'] };
console.log('User object:', user);

// Table output for arrays or objects
console.table([
  { name: 'John', age: 30, role: 'admin' },
  { name: 'Jane', age: 25, role: 'user' },
  { name: 'Bob', age: 40, role: 'guest' }
]);

// Timing operations
console.time('operation');
// Perform some operations...
for (let i = 0; i < 1000000; i++) {
  // Do something
}
console.timeEnd('operation'); // Outputs: operation: 4.269ms

// Grouping related logs
console.group('User Processing');
console.log('Loading user data...');
console.log('Validating user...');
console.log('Updating user profile...');
console.groupEnd();

// Stack trace
console.trace('Trace message');

{
  "timestamp": "2023-11-28T15:24:39.123Z",
  "level": "error",
  "message": "Failed to connect to database",
  "service": "user-service",
  "context": {
    "requestId": "req-123-456",
    "userId": "user-789",
    "databaseHost": "db.example.com"
  },
  "error": {
    "name": "ConnectionError",
    "message": "Connection refused",
    "stack": "..."
  }
}

const winston = require('winston');

// Create a logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'user-service' },
  transports: [
    // Write logs to a file
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

// If not in production, also log to the console
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple(),
  }));
}

// Usage
logger.log('info', 'Hello distributed log files!');
logger.info('Hello again distributed logs');
logger.error('Something went wrong', { additionalInfo: 'error details' });

const winston = require('winston');
const { format } = winston;
const { combine, timestamp, label, printf } = format;

// Custom format
const myFormat = printf(({ level, message, label, timestamp }) => {
  return `${timestamp} [${label}] ${level}: ${message}`;
});

const logger = winston.createLogger({
  format: combine(
    label({ label: 'API Service' }),
    timestamp(),
    myFormat
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

logger.info('Application started');

const pino = require('pino');

// Create a logger
const logger = pino({
  level: 'info',
  timestamp: pino.stdTimeFunctions.isoTime,
  base: { pid: process.pid, hostname: require('os').hostname() }
});

// Usage
logger.info('Application started');
logger.info({ user: 'john' }, 'User logged in');
logger.error({ err: new Error('Connection failed') }, 'Database connection error');

const express = require('express');
const pino = require('pino');
const pinoHttp = require('pino-http');

const app = express();
const logger = pino();
const httpLogger = pinoHttp({ logger });

// Add request logging middleware
app.use(httpLogger);

app.get('/', (req, res) => {
  req.log.info('User accessed homepage');
  res.send('Hello World!');
});

app.get('/error', (req, res) => {
  req.log.error('Something went wrong');
  res.status(500).send('Error!');
});

app.listen(8080, () => {
  logger.info('Server started on port 8080');
});

const bunyan = require('bunyan');

// Create a logger
const logger = bunyan.createLogger({
  name: 'myapp',
  streams: [
    {
      level: 'info',
      stream: process.stdout
    },
    {
      level: 'error',
      path: 'error.log'
    }
  ],
  serializers: bunyan.stdSerializers
});

// Usage
logger.info('Application started');
logger.info({ user: 'john' }, 'User logged in');
logger.error({ err: new Error('Connection failed') }, 'Database connection error');

const winston = require('winston');

// Create a base logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [new winston.transports.Console()]
});

// Create a child logger with request context
function createRequestLogger(req) {
  return logger.child({
    requestId: req.id,
    method: req.method,
    url: req.url,
    ip: req.ip,
    userId: req.user ? req.user.id : 'anonymous'
  });
}

// Usage in Express middleware
app.use((req, res, next) => {
  req.id = generateRequestId();
  req.logger = createRequestLogger(req);
  req.logger.info('Request received');

  const start = Date.now();

  res.on('finish', () => {
    const duration = Date.now() - start;
    req.logger.info({
      statusCode: res.statusCode,
      duration: duration
    }, 'Request completed');
  });

  next();
});

function generateRequestId() {
  return Date.now().toString(36) + Math.random().toString(36).substring(2);
}

const winston = require('winston');
require('winston-daily-rotate-file');

const transport = new winston.transports.DailyRotateFile({
  filename: 'application-%DATE%.log',
  datePattern: 'YYYY-MM-DD',
  zippedArchive: true,
  maxSize: '20m',
  maxFiles: '14d'
});

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    transport,
    new winston.transports.Console()// Optional console transport
  ]
});

logger.info('Hello rotated logs');

const winston = require('winston');
require('winston-elasticsearch');

const esTransportOpts = {
  level: 'info',
  clientOpts: {
    node: 'http://localhost:9200'
  },
  indexPrefix: 'app-logs'
};

const logger = winston.createLogger({
  transports: [
    new winston.transports.Elasticsearch(esTransportOpts),
    new winston.transports.Console()// Optional console transport
  ]
});

logger.info('This log will go to Elasticsearch');

const winston = require('winston');

// Custom format to sanitize sensitive data
const sanitizeFormat = winston.format((info) => {
  if (info.user && info.user.password) {
    info.user.password = '[REDACTED]';
  }

  if (info.user && info.user.creditCard) {
    info.user.creditCard = '[REDACTED]';
  }

  if (info.headers && info.headers.authorization) {
    info.headers.authorization = '[REDACTED]';
  }

  return info;
});

const logger = winston.createLogger({
  format: winston.format.combine(
    sanitizeFormat(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.Console()
  ]
});

// This sensitive data will be sanitized in the logs
logger.info({
  message: 'User registered',
  user: {
    name: 'John',
    email: 'john@example.com',
    password: 'secret123',
    creditCard: '4111-1111-1111-1111'
  },
  headers: {
    authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
  }
});

const debug = require('debug');

// Create named debuggers
const dbDebug = debug('app:db');
const apiDebug = debug('app:api');
const authDebug = debug('app:auth');

// Usage
dbDebug('Connected to database');
apiDebug('API request received at /users');
authDebug('User authenticated: %o', { id: 123, roles: ['admin'] });

// Enable with environment variable:
// DEBUG=app:* node app.js
// or
// DEBUG=app:db,app:auth node app.js

const express = require('express');
const { v4: uuidv4 } = require('uuid');
const winston = require('winston');
const app = express();

// Create a logger
const logger = winston.createLogger({
  transports: [new winston.transports.Console()],
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  )
});

// Correlation ID middleware
app.use((req, res, next) => {
  // Extract correlation ID from the request header or generate a new one
  const correlationId = req.headers['x-correlation-id'] || uuidv4();

  // Add it to the response headers
  res.setHeader('x-correlation-id', correlationId);

  // Add it to the request object
  req.correlationId = correlationId;

  // Create a request-specific logger
  req.logger = logger.child({ correlationId });

  req.logger.info({
    message: 'Request received',
    method: req.method,
    url: req.url
  });

  next();
});

// Routes
app.get('/', (req, res) => {
  req.logger.info('Processing home request');
  res.send('Hello World');
});

app.get('/error', (req, res) => {
  req.logger.error('Error occurred in request');
  res.status(500).send('Error');
});

app.listen(8080, () => {
  logger.info('Server started on port 8080');
});