Logging

use stdlib.logging.*

main() = {
    # Create a console logger
    logger = newConsoleLogger()

    # Log some messages at different levels
    logInfo(logger, "Application started")
    logDebug(logger, "Initializing components...")
    logWarn(logger, "Configuration file not found, using defaults")
    logError(logger, "Failed to connect to database")

    # Always flush to ensure output is written
    consoleFlush(logger)

    0
}

# Log levels are defined as a variant type
type LogLevel = LDebug | LInfo | LWarn | LError | LFatal

use stdlib.logging.*

main() = {
    # Create a logger that only shows warnings and above
    logger = newConsoleLoggerWithLevel(LWarn)

    # These will be filtered out (below minimum level)
    logDebug(logger, "This debug message won't appear")
    logInfo(logger, "This info message won't appear either")

    # These will be shown (at or above minimum level)
    logWarn(logger, "This warning will appear")
    logError(logger, "This error will appear")
    logFatal(logger, "This fatal message will appear")

    consoleFlush(logger)
    0
}

use stdlib.logging.*

main() = {
    logger = newConsoleLogger()

    # Log with source identifiers
    logInfoFrom(logger, "Database", "Connection pool initialized with 10 connections")
    logInfoFrom(logger, "HTTP", "Server listening on port 8080")
    logWarnFrom(logger, "Cache", "Cache miss rate above 50%")
    logErrorFrom(logger, "Auth", "Invalid token received from client 192.168.1.100")

    consoleFlush(logger)
    0
}

use stdlib.logging.*

main() = {
    # Create a stderr logger (useful for separating logs from program output)
    logger = newStderrLogger()

    # Log to stderr
    stderrLog(logger, makeEntry(LInfo, "This goes to stderr"))
    stderrLog(logger, makeEntry(LError, "Errors also go to stderr"))

    stderrFlush(logger)

    # Regular output still goes to stdout
    println("This goes to stdout")

    0
}

use stdlib.logging.*

main() = {
    # Create a file logger - logs are appended to the file
    logger = newFileLogger("/var/log/myapp.log")

    # Log some messages
    fileLogInfo(logger, "Application started")
    fileLogInfo(logger, "Processing request from user 42")
    fileLogWarn(logger, "Response time exceeded 500ms")
    fileLogError(logger, "Failed to write to cache")

    # File is automatically flushed after each write
    fileFlush(logger)

    println("Logs written to /var/log/myapp.log")
    0
}

use stdlib.logging.*

main() = {
    # Only log warnings and above to file
    logger = newFileLoggerWithLevel("/var/log/myapp-errors.log", LWarn)

    fileLogDebug(logger, "Debug - won't be written")
    fileLogInfo(logger, "Info - won't be written")
    fileLogWarn(logger, "Warning - will be written")
    fileLogError(logger, "Error - will be written")

    0
}

use stdlib.logging.*

main() = {
    # Create a rotating file logger
    # - Path: /var/log/myapp.log
    # - Max size: 10MB (10 * 1024 * 1024 bytes)
    # - Keep 5 backup files
    maxSize = 10 * 1024 * 1024  # 10 MB
    maxBackups = 5

    logger = newRotatingFileLogger("/var/log/myapp.log", maxSize, maxBackups)

    # Log messages as usual
    rotatingLogInfo(logger, "Application started")
    rotatingLogInfo(logger, "Processing data...")

    # When myapp.log reaches 10MB:
    # - myapp.log.5 is deleted (if exists)
    # - myapp.log.4 -> myapp.log.5
    # - myapp.log.3 -> myapp.log.4
    # - myapp.log.2 -> myapp.log.3
    # - myapp.log.1 -> myapp.log.2
    # - myapp.log   -> myapp.log.1
    # - New myapp.log is created

    0
}

use stdlib.logging.*

main() = {
    # Create a log entry manually
    entry = makeEntry(LInfo, "User logged in")

    # The entry contains:
    # - level: LInfo
    # - message: "User logged in"
    # - timestamp: current time in milliseconds
    # - source: "" (empty)

    # Create an entry with a source
    entryWithSource = makeEntryFrom(LWarn, "Disk space low", "Storage")

    # Format entries as strings
    formatted = formatEntry(entry)
    println(formatted)
    # Output: [2026-01-15 14:50:00.123] [INFO] User logged in

    formattedWithSource = formatEntry(entryWithSource)
    println(formattedWithSource)
    # Output: [2026-01-15 14:50:00.124] [WARN] [Storage] Disk space low

    0
}

# The LogEntry record type
type LogEntry = {
    level: LogLevel,     # The severity level
    message: String,     # The log message
    timestamp: Int,      # Unix timestamp in milliseconds
    source: String       # Optional source identifier (empty string if not set)
}

# Example: Create a custom log entry
customEntry = LogEntry(
    LError,
    "Connection timeout after 30 seconds",
    Time.now(),
    "NetworkClient"
)

# Access fields
println("Level: " ++ levelToString(customEntry.level))   # "ERROR"
println("Message: " ++ customEntry.message)
println("Source: " ++ customEntry.source)                # "NetworkClient"

use stdlib.logging.*

# Define our custom logger type
type PrefixLogger = { prefix: String, minLevel: LogLevel }

# Constructor function
newPrefixLogger(prefix) = PrefixLogger(prefix, LDebug)

# Implement the Logger trait
PrefixLogger: Logger
    log(self, entry: LogEntry) -> () = {
        if levelPriority(entry.level) >= levelPriority(self.minLevel) then
            println("[" ++ self.prefix ++ "] " ++ formatEntry(entry))
        else ()
    }
    flush(self) -> () = flushStdout()
end

main() = {
    # Create loggers for different components
    dbLogger = newPrefixLogger("DATABASE")
    httpLogger = newPrefixLogger("HTTP-SERVER")

    # Use the loggers with method syntax
    dbLogger.log(makeEntry(LInfo, "Connected to PostgreSQL"))
    dbLogger.log(makeEntry(LDebug, "Executing query: SELECT * FROM users"))

    httpLogger.log(makeEntry(LInfo, "Listening on port 8080"))
    httpLogger.log(makeEntry(LWarn, "Slow response: 2500ms"))

    dbLogger.flush()
    httpLogger.flush()

    0
}

use stdlib.logging.*
use stdlib.json.*

# JSON logger type
type JsonLogger = { minLevel: LogLevel, includeTimestamp: Bool }

newJsonLogger() = JsonLogger(LDebug, true)
newJsonLoggerWithOptions(minLevel, includeTimestamp) = JsonLogger(minLevel, includeTimestamp)

# Implement the Logger trait
JsonLogger: Logger
    log(self, entry: LogEntry) -> () = {
        if levelPriority(entry.level) >= levelPriority(self.minLevel) then {
            # Build JSON object
            obj = %{
                "level": levelToString(entry.level),
                "message": entry.message
            }

            # Optionally add timestamp
            objWithTs = if self.includeTimestamp then
                obj.put("timestamp", entry.timestamp)
            else obj

            # Add source if present
            finalObj = if entry.source != "" then
                objWithTs.put("source", entry.source)
            else objWithTs

            println(toJson(finalObj))
        } else ()
    }
    flush(self) -> () = flushStdout()
end

main() = {
    logger = newJsonLogger()

    logger.log(makeEntry(LInfo, "Server started"))
    logger.log(makeEntryFrom(LError, "Connection refused", "Database"))

    logger.flush()
    0
}

use stdlib.logging.*

# Store log level in mvar for runtime changes
mvar logLevel: LogLevel = LDebug

# Global logger that checks the mvar
globalLog(level, message) = {
    minLevel = logLevel
    if levelPriority(level) >= levelPriority(minLevel) then
        println(formatEntry(makeEntry(level, message)))
    else ()
}

setGlobalLogLevel(level) = {
    logLevel = level
}

main() = {
    globalLog(LDebug, "Starting up")      # Visible
    globalLog(LInfo, "Ready")              # Visible

    # Change level at runtime
    setGlobalLogLevel(LWarn)

    globalLog(LDebug, "Debug info")        # Filtered out
    globalLog(LWarn, "Warning!")           # Visible
    globalLog(LError, "Error occurred")    # Visible

    flushStdout()
    0
}

use stdlib.logging.*

# Define a logger configuration type
type GlobalLogger = { minLevel: LogLevel }

# Store the logger config in an mvar
mvar logger: GlobalLogger = GlobalLogger(LDebug)

globalLog(level, message) = {
    cfg = logger
    if levelPriority(level) >= levelPriority(cfg.minLevel) then
        println(formatEntry(makeEntry(level, message)))
    else ()
}

setLogLevel(level) = {
    logger = GlobalLogger(level)
}

main() = {
    globalLog(LInfo, "Application started")
    globalLog(LDebug, "Debug details")

    # Change configuration
    setLogLevel(LError)

    globalLog(LWarn, "This is filtered")
    globalLog(LError, "This is visible")

    0
}

# GOOD: Appropriate levels
logDebug(logger, "Cache key: user_42_profile")     # Implementation details
logInfo(logger, "User 42 logged in")                # Normal events
logWarn(logger, "API rate limit at 80%")            # Potential issues
logError(logger, "Payment processing failed")       # Actual failures
logFatal(logger, "Database connection lost")        # Critical failures

# BAD: Inappropriate levels
logError(logger, "User clicked button")  # This is INFO at most
logDebug(logger, "Server crashed!")      # This should be FATAL

# GOOD: Includes useful context
logInfo(logger, "Order #12345 processed for user 42, total: $99.99")
logError(logger, "Failed to send email to user@example.com: timeout after 30s")

# BAD: Missing context
logInfo(logger, "Order processed")    # Which order? For whom?
logError(logger, "Email failed")      # To whom? Why?

# GOOD: Easy to filter and trace
logInfoFrom(logger, "OrderService", "Processing order #12345")
logInfoFrom(logger, "PaymentGateway", "Charging card ending in 4242")
logInfoFrom(logger, "EmailService", "Sending confirmation to user@example.com")

# When something goes wrong, you can easily trace the flow:
# [OrderService] Processing order #12345
# [PaymentGateway] Charging card ending in 4242
# [PaymentGateway] ERROR: Card declined
# [OrderService] Order #12345 failed: payment declined

use stdlib.logging.*

# Get log level from environment or configuration
getLogLevel(env) = match env {
    "development" -> LDebug    # Show everything in dev
    "staging"     -> LInfo     # Info and above in staging
    "production"  -> LWarn     # Only warnings and errors in prod
    _             -> LInfo     # Default to info
}

main() = {
    env = getEnv("APP_ENV").getOrElse("development")
    level = getLogLevel(env)

    logger = newConsoleLoggerWithLevel(level)

    logDebug(logger, "Detailed debug info")  # Only in development
    logInfo(logger, "Server starting...")     # Development + staging
    logWarn(logger, "High memory usage")      # All environments
    logError(logger, "Request failed")        # All environments

    consoleFlush(logger)
    0
}

use stdlib.logging.*

# Application logger that writes to both console and rotating file
type AppLogger = {
    console: ConsoleLogger,
    file: RotatingFileLogger,
    appName: String
}

newAppLogger(appName, logPath) = {
    console = newConsoleLoggerWithLevel(LInfo)
    file = newRotatingFileLoggerWithLevel(
        logPath,
        LDebug,           # File gets all levels
        5 * 1024 * 1024,  # 5 MB max size
        3                  # Keep 3 backups
    )
    AppLogger(console, file, appName)
}

# Log to both console and file
appLog(logger, entry) = {
    # Add app name as source if not already set
    entryWithSource = if entry.source == "" then
        LogEntry(entry.level, entry.message, entry.timestamp, logger.appName)
    else entry

    # Log to console (respects its level filter)
    consoleLog(logger.console, entryWithSource)

    # Log to file (respects its level filter)
    rotatingFileLog(logger.file, entryWithSource)
}

appFlush(logger) = {
    consoleFlush(logger.console)
    rotatingFileFlush(logger.file)
}

# Convenience functions
appDebug(logger, msg) = appLog(logger, makeEntry(LDebug, msg))
appInfo(logger, msg) = appLog(logger, makeEntry(LInfo, msg))
appWarn(logger, msg) = appLog(logger, makeEntry(LWarn, msg))
appError(logger, msg) = appLog(logger, makeEntry(LError, msg))

main() = {
    # Initialize application logger
    logger = newAppLogger("MyApp", "/var/log/myapp/app.log")

    appInfo(logger, "Application starting...")
    appDebug(logger, "Loading configuration from /etc/myapp/config.json")
    appInfo(logger, "Configuration loaded successfully")

    appDebug(logger, "Connecting to database...")
    appInfo(logger, "Database connection established")

    appInfo(logger, "Starting HTTP server on port 8080")
    appWarn(logger, "Running in development mode - not for production use")

    # Simulate some work
    appDebug(logger, "Processing incoming request: GET /api/users")
    appInfo(logger, "Request completed in 45ms")

    appInfo(logger, "Shutting down gracefully...")
    appFlush(logger)

    0
}