Logging

const winston = require('winston');
const fs = require('fs');
const os = require('os');
const path = require('path');

class MinuteRotatingTransport extends winston.transports.File {
  constructor(options) {
    super(options);
    this.logDir = options.logDir;
    this.serviceName = options.serviceName;
    this.currentMinute = null;
    this.updateFilename();
    
    // Check for rotation every 10 seconds
    setInterval(() => {
      this.checkRotation();
    }, 10000);
  }
  
  updateFilename() {
    const now = new Date();
    const timestamp = now.toISOString()
      .replace(/[-:]/g, '')
      .replace(/\.\d{3}Z$/, '_00Z')
      .replace(/T(\d{2})(\d{2})/, 'T$1_$2');
    this.filename = path.join(this.logDir, `${this.serviceName}-${timestamp}.log`);
    this.currentMinute = timestamp.slice(0, -4); // Remove '_00Z' suffix
  }
  
  checkRotation() {
    const now = new Date();
    const currentMinute = now.toISOString()
      .replace(/[-:]/g, '')
      .replace(/\.\d{3}Z$/, '')
      .replace(/T(\d{2})(\d{2})/, 'T$1_$2')
      .slice(0, -2); // Remove seconds
      
    if (this.currentMinute !== currentMinute) {
      this.close();
      this.updateFilename();
      this.open();
    }
  }
}

function setupLogging() {
  // Create instance-specific directory
  const instanceId = os.hostname();
  const logDir = `/mnt/logs/${instanceId}`;
  
  if (!fs.existsSync(logDir)) {
    fs.mkdirSync(logDir, { recursive: true });
  }
  
  // Configure Winston logger with minute rotation
  const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
      winston.format.timestamp(),
      winston.format.printf(({ timestamp, level, message }) => {
        return `${timestamp} - ${level}: ${message}`;
      })
    ),
    transports: [
      new winston.transports.Console(),
      new MinuteRotatingTransport({ 
        logDir: logDir,
        serviceName: 'app'
      })
    ]
  });
  
  return logger;
}

// Usage
const logger = setupLogging();
logger.info('Application started - logs automatically flowing to S3');
logger.error('Sample error message');

package main

import (
    "fmt"
    "log"
    "os"
    "path/filepath"
    "sync"
    "time"
)

type MinuteRotatingLogger struct {
    logDir      string
    serviceName string
    currentFile *os.File
    currentMinute string
    logger      *log.Logger
    mutex       sync.Mutex
}

func NewMinuteRotatingLogger(logDir, serviceName string) *MinuteRotatingLogger {
    mrl := &MinuteRotatingLogger{
        logDir:      logDir,
        serviceName: serviceName,
    }
    mrl.rotateIfNeeded()
    
    return mrl
}

func (mrl *MinuteRotatingLogger) rotateIfNeeded() {
    mrl.mutex.Lock()
    defer mrl.mutex.Unlock()
    
    now := time.Now().UTC()
    currentMinute := now.Format("20060102T15_04")
    
    if mrl.currentMinute != currentMinute {
        if mrl.currentFile != nil {
            mrl.currentFile.Close()
        }
        
        timestamp := now.Format("20060102T15_04_00Z")
        logFile := filepath.Join(mrl.logDir, fmt.Sprintf("%s-%s.log", mrl.serviceName, timestamp))
        
        file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
        if err != nil {
            log.Fatalf("Failed to open log file: %v", err)
        }
        
        mrl.currentFile = file
        mrl.currentMinute = currentMinute
        mrl.logger = log.New(file, "", log.LstdFlags|log.Lshortfile)
    }
}

func (mrl *MinuteRotatingLogger) Printf(format string, v ...interface{}) {
    mrl.mutex.Lock()
    defer mrl.mutex.Unlock()
    mrl.rotateIfNeeded()
    mrl.logger.Printf(format, v...)
}

func (mrl *MinuteRotatingLogger) Println(v ...interface{}) {
    mrl.mutex.Lock()
    defer mrl.mutex.Unlock()
    mrl.rotateIfNeeded()
    mrl.logger.Println(v...)
}

func setupLogging() *MinuteRotatingLogger {
    // Create instance-specific directory
    hostname, _ := os.Hostname()
    logDir := filepath.Join("/mnt/logs", hostname)
    os.MkdirAll(logDir, 0755)
    
    return NewMinuteRotatingLogger(logDir, "app")
}

func main() {
    logger := setupLogging()
    logger.Println("Application started - logs automatically flowing to S3")
    logger.Println("Sample log message")
}

import java.io.IOException;
import java.net.InetAddress;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Logger;
import java.util.logging.LogRecord;
import java.util.logging.SimpleFormatter;

class MinuteRotatingFileHandler extends Handler {
    private final Path logDir;
    private final String serviceName;
    private FileHandler currentHandler;
    private String currentMinute;
    private final ScheduledExecutorService scheduler;

    public MinuteRotatingFileHandler(Path logDir, String serviceName) throws IOException {
        this.logDir = logDir;
        this.serviceName = serviceName;
        this.scheduler = Executors.newScheduledThreadPool(1);
        
        rotateIfNeeded();
        
        // Check for rotation every 10 seconds
        scheduler.scheduleAtFixedRate(this::rotateIfNeeded, 10, 10, TimeUnit.SECONDS);
    }

    private synchronized void rotateIfNeeded() {
        try {
            LocalDateTime now = LocalDateTime.now(ZoneOffset.UTC);
            String minute = now.format(DateTimeFormatter.ofPattern("yyyyMMdd'T'HH_mm"));
            
            if (!minute.equals(currentMinute)) {
                if (currentHandler != null) {
                    currentHandler.close();
                }
                
                String timestamp = now.format(DateTimeFormatter.ofPattern("yyyyMMdd'T'HH_mm_00'Z'"));
                String logFile = logDir.resolve(serviceName + "-" + timestamp + ".log").toString();
                
                currentHandler = new FileHandler(logFile, true);
                currentHandler.setFormatter(new SimpleFormatter());
                currentMinute = minute;
            }
        } catch (IOException e) {
            System.err.println("Failed to rotate log file: " + e.getMessage());
        }
    }

    @Override
    public synchronized void publish(LogRecord record) {
        rotateIfNeeded();
        if (currentHandler != null) {
            currentHandler.publish(record);
        }
    }

    @Override
    public void flush() {
        if (currentHandler != null) {
            currentHandler.flush();
        }
    }

    @Override
    public void close() throws SecurityException {
        if (currentHandler != null) {
            currentHandler.close();
        }
        scheduler.shutdown();
    }
}

public class LoggingSetup {
    public static Logger setupLogging() throws IOException {
        // Create instance-specific directory
        String hostname = InetAddress.getLocalHost().getHostName();
        Path logDir = Paths.get("/mnt/logs", hostname);
        Files.createDirectories(logDir);
        
        // Configure Java logging with minute rotation
        Logger logger = Logger.getLogger("AppLogger");
        MinuteRotatingFileHandler fileHandler = new MinuteRotatingFileHandler(logDir, "app");
        logger.addHandler(fileHandler);
        
        return logger;
    }
    
    public static void main(String[] args) throws IOException {
        Logger logger = setupLogging();
        logger.info("Application started - logs automatically flowing to S3");
        logger.severe("Sample error message");
    }
}

-- Analyze log volume by hour
SELECT 
  date_format(from_iso8601_timestamp(timestamp), '%Y-%m-%d %H:00:00') as hour,
  COUNT(*) as log_count,
  COUNT(DISTINCT instance_id) as active_instances
FROM application_logs
WHERE timestamp >= date_format(date_add('day', -7, now()), '%Y-%m-%d')
GROUP BY date_format(from_iso8601_timestamp(timestamp), '%Y-%m-%d %H:00:00')
ORDER BY hour;

-- Find instances with unusual activity
SELECT 
  instance_id,
  COUNT(*) as total_logs,
  COUNT(CASE WHEN level = 'ERROR' THEN 1 END) as error_logs,
  COUNT(CASE WHEN level = 'WARN' THEN 1 END) as warn_logs
FROM application_logs
WHERE timestamp >= date_format(date_add('hour', -1, now()), '%Y-%m-%d %H:%i:%s')
GROUP BY instance_id
HAVING COUNT(*) > 1000 OR COUNT(CASE WHEN level = 'ERROR' THEN 1 END) > 10
ORDER BY total_logs DESC;

-- Search for specific patterns in log messages
SELECT timestamp, instance_id, level, message
FROM application_logs
WHERE message LIKE '%timeout%'
  OR message LIKE '%connection%'
  OR message LIKE '%failed%'
AND timestamp >= date_format(date_add('hour', -6, now()), '%Y-%m-%d %H:%i:%s')
ORDER BY timestamp DESC;

-- Analyze function call patterns
SELECT 
  module,
  function,
  COUNT(*) as call_count,
  COUNT(CASE WHEN level = 'ERROR' THEN 1 END) as error_count
FROM application_logs
WHERE timestamp >= date_format(date_add('day', -1, now()), '%Y-%m-%d')
GROUP BY module, function
HAVING COUNT(*) > 100
ORDER BY call_count DESC;