📊 Metrics & Monitoring Module¶

-- Get current CPU usage
local cpu_usage = metrics.system_cpu()
log.info("CPU Usage: " .. string.format("%.1f%%", cpu_usage))

-- Get memory information
local memory_info = metrics.system_memory()
log.info("Memory: " .. string.format("%.1f%% (%.0f/%.0f MB)", 
    memory_info.percent, memory_info.used_mb, memory_info.total_mb))

-- Get disk usage
local disk_info = metrics.system_disk("/")
log.info("Disk: " .. string.format("%.1f%% (%.1f/%.1f GB)", 
    disk_info.percent, disk_info.used_gb, disk_info.total_gb))

-- Check specific disk path
local var_disk = metrics.system_disk("/var")
log.info("Var disk usage: " .. string.format("%.1f%%", var_disk.percent))

-- Get Go runtime metrics
local runtime = metrics.runtime_info()
log.info("Runtime Information:")
log.info("  Goroutines: " .. runtime.goroutines)
log.info("  CPU cores: " .. runtime.num_cpu)
log.info("  Heap allocated: " .. string.format("%.1f MB", runtime.heap_alloc_mb))
log.info("  Heap system: " .. string.format("%.1f MB", runtime.heap_sys_mb))
log.info("  GC cycles: " .. runtime.num_gc)
log.info("  Go version: " .. runtime.go_version)

-- Set simple gauge values
metrics.gauge("cpu_temperature", 65.4)
metrics.gauge("active_connections", 142)
metrics.gauge("queue_size", 23)

-- Set gauge with tags
metrics.gauge("memory_usage", memory_percent, {
    server = "web-01",
    environment = "production",
    region = "us-east-1"
})

-- Update deployment status
metrics.gauge("deployment_progress", 75.5, {
    app = "frontend",
    version = "v2.1.0"
})

-- Increment counters
local total_requests = metrics.counter("http_requests_total", 1)
local error_count = metrics.counter("http_errors_total", 1, {
    status_code = "500",
    endpoint = "/api/users"
})

-- Bulk increment
local processed = metrics.counter("messages_processed", 50, {
    queue = "user_notifications",
    priority = "high"
})

log.info("Total requests processed: " .. total_requests)

-- Record response times
metrics.histogram("response_time_ms", 245.6, {
    endpoint = "/api/users",
    method = "GET"
})

-- Record payload sizes
metrics.histogram("payload_size_bytes", 1024, {
    content_type = "application/json"
})

-- Record batch sizes
metrics.histogram("batch_size", 150, {
    operation = "bulk_insert",
    table = "user_events"
})

-- Time function execution automatically
local duration = metrics.timer("database_query", function()
    -- Simulate database query
    local result = exec.run("sleep 0.1")
    return result
end, {
    query_type = "select",
    table = "users"
})

log.info("Database query took: " .. string.format("%.2f ms", duration))

-- Time complex operations
local processing_time = metrics.timer("data_processing", function()
    -- Process large dataset
    local data = {}
    for i = 1, 100000 do
        data[i] = math.sqrt(i) * 2.5
    end
    return #data
end, {
    operation = "mathematical_computation",
    size = "large"
})

log.info("Data processing completed in: " .. string.format("%.2f ms", processing_time))

-- Get comprehensive health status
local health = metrics.health_status()
log.info("Overall Health Status: " .. health.overall)

-- Check individual components
local components = {"cpu", "memory", "disk"}
for _, component in ipairs(components) do
    local comp_info = health[component]
    if comp_info then
        local status_icon = "✅"
        if comp_info.status == "warning" then
            status_icon = "⚠️"
        elseif comp_info.status == "critical" then
            status_icon = "❌"
        end

        log.info(string.format("  %s %s: %.1f%% (%s)", 
            status_icon, component:upper(), comp_info.usage, comp_info.status))
    end
end

-- Create health check function
function check_application_health()
    local health_score = 100
    local issues = {}

    -- Check database connectivity
    local db_result = exec.run("pg_isready -h localhost -p 5432")
    if db_result ~= "" then
        health_score = health_score - 20
        table.insert(issues, "Database connection failed")
    end

    -- Check disk space
    local disk = metrics.system_disk("/")
    if disk.percent > 90 then
        health_score = health_score - 30
        table.insert(issues, "Disk space critical: " .. string.format("%.1f%%", disk.percent))
    end

    -- Check memory usage
    local memory = metrics.system_memory()
    if memory.percent > 85 then
        health_score = health_score - 25
        table.insert(issues, "Memory usage high: " .. string.format("%.1f%%", memory.percent))
    end

    -- Record health score
    metrics.gauge("application_health_score", health_score)

    if health_score < 70 then
        metrics.alert("application_health", {
            level = "warning",
            message = "Application health degraded: " .. table.concat(issues, ", "),
            score = health_score
        })
    end

    return health_score >= 70
end

-- Use in tasks
Modern DSLs = {
    health_monitoring = {
        tasks = {
            health_check = {
                command = function()
                    local healthy = check_application_health()
                    return healthy, healthy and "System healthy" or "System health issues detected"
                end
            }
        }
    }
}

-- Simple threshold alert
local cpu = metrics.system_cpu()
if cpu > 80 then
    metrics.alert("high_cpu_usage", {
        level = "warning",
        message = "CPU usage is high: " .. string.format("%.1f%%", cpu),
        threshold = 80,
        value = cpu,
        severity = "medium"
    })
end

-- Complex alert with multiple conditions
local memory = metrics.system_memory()
local disk = metrics.system_disk()

if memory.percent > 90 and disk.percent > 85 then
    metrics.alert("resource_exhaustion", {
        level = "critical",
        message = string.format("Critical resource usage - Memory: %.1f%%, Disk: %.1f%%", 
            memory.percent, disk.percent),
        memory_usage = memory.percent,
        disk_usage = disk.percent,
        recommended_action = "Scale up resources immediately"
    })
end

-- Application-specific alerts
local queue_size = state.get("task_queue_size", 0)
if queue_size > 1000 then
    metrics.alert("queue_backlog", {
        level = "warning", 
        message = "Task queue backlog detected: " .. queue_size .. " items",
        queue_size = queue_size,
        estimated_processing_time = queue_size * 2 .. " seconds"
    })
end

-- Get specific custom metric
local cpu_metric = metrics.get_custom("cpu_temperature")
if cpu_metric then
    log.info("CPU Temperature metric: " .. data.to_json(cpu_metric))
end

-- List all custom metrics
local all_metrics = metrics.list_custom()
log.info("Total custom metrics: " .. #all_metrics)
for i, metric_name in ipairs(all_metrics) do
    log.info("  " .. i .. ". " .. metric_name)
end

Modern DSLs = {
    performance_monitoring = {
        tasks = {
            monitor_api_performance = {
                command = function()
                    -- Start monitoring session
                    log.info("Starting API performance monitoring...")

                    -- Simulate API calls and measure performance
                    for i = 1, 10 do
                        local api_time = metrics.timer("api_call_" .. i, function()
                            -- Simulate API call
                            exec.run("curl -s -o /dev/null -w '%{time_total}' https://api.example.com/health")
                        end, {
                            endpoint = "health",
                            call_number = tostring(i)
                        })

                        -- Record response time
                        metrics.histogram("api_response_time", api_time, {
                            endpoint = "health"
                        })

                        -- Check if response time is acceptable
                        if api_time > 1000 then -- 1 second
                            metrics.counter("slow_api_calls", 1, {
                                endpoint = "health"
                            })

                            metrics.alert("slow_api_response", {
                                level = "warning",
                                message = string.format("Slow API response: %.2f ms", api_time),
                                response_time = api_time,
                                threshold = 1000
                            })
                        end

                        -- Brief delay between calls
                        exec.run("sleep 0.1")
                    end

                    -- Get summary statistics
                    local system_health = metrics.health_status()
                    log.info("System health after API tests: " .. system_health.overall)

                    return true, "API performance monitoring completed"
                end
            }
        }
    }
}