OpenResty Production Setup: Supercharge with Lua-Based Metrics and Monitoring

-- /usr/local/openresty/nginx/lua/metrics.lua
local _M = {}

local cjson = require "cjson"
local ngx = require "ngx"
local shared_metrics = ngx.shared.metrics

-- Metric types
local METRIC_TYPES = {
    COUNTER = "counter",
    GAUGE = "gauge",
    HISTOGRAM = "histogram",
    SUMMARY = "summary"
}

-- Initialize metrics storage
local function init_metrics()
    if not shared_metrics:get("initialized") then
        shared_metrics:set("initialized", true)
        shared_metrics:set("counters", cjson.encode({}))
        shared_metrics:set("gauges", cjson.encode({}))
        shared_metrics:set("histograms", cjson.encode({}))
        shared_metrics:set("summaries", cjson.encode({}))
    end
end

-- Get metrics data
local function get_metrics_data(metric_type)
    local data = shared_metrics:get(metric_type .. "s")
    if data then
        return cjson.decode(data)
    end
    return {}
end

-- Set metrics data
local function set_metrics_data(metric_type, data)
    shared_metrics:set(metric_type .. "s", cjson.encode(data))
end

-- Counter operations
function _M.counter(name, value, labels)
    init_metrics()
    local counters = get_metrics_data("counter")
    local key = name .. (labels and ":" .. cjson.encode(labels) or "")
    
    if not counters[key] then
        counters[key] = {
            name = name,
            labels = labels or {},
            value = 0
        }
    end
    
    counters[key].value = counters[key].value + (value or 1)
    set_metrics_data("counter", counters)
end

-- Gauge operations
function _M.gauge(name, value, labels)
    init_metrics()
    local gauges = get_metrics_data("gauge")
    local key = name .. (labels and ":" .. cjson.encode(labels) or "")
    
    gauges[key] = {
        name = name,
        labels = labels or {},
        value = value
    }
    set_metrics_data("gauge", gauges)
end

-- Histogram operations
function _M.histogram(name, value, labels, buckets)
    init_metrics()
    local histograms = get_metrics_data("histogram")
    local key = name .. (labels and ":" .. cjson.encode(labels) or "")
    
    if not histograms[key] then
        histograms[key] = {
            name = name,
            labels = labels or {},
            buckets = buckets or {0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10},
            counts = {},
            sum = 0,
            count = 0
        }
    end
    
    local histogram = histograms[key]
    histogram.sum = histogram.sum + value
    histogram.count = histogram.count + 1
    
    -- Update bucket counts
    for i, bucket in ipairs(histogram.buckets) do
        if value <= bucket then
            histogram.counts[i] = (histogram.counts[i] or 0) + 1
        end
    end
    
    set_metrics_data("histogram", histograms)
end

-- Summary operations
function _M.summary(name, value, labels, quantiles)
    init_metrics()
    local summaries = get_metrics_data("summary")
    local key = name .. (labels and ":" .. cjson.encode(labels) or "")
    
    if not summaries[key] then
        summaries[key] = {
            name = name,
            labels = labels or {},
            quantiles = quantiles or {0.5, 0.9, 0.95, 0.99},
            values = {},
            sum = 0,
            count = 0
        }
    end
    
    local summary = summaries[key]
    table.insert(summary.values, value)
    summary.sum = summary.sum + value
    summary.count = summary.count + 1
    
    -- Keep only last 1000 values for quantile calculation
    if #summary.values > 1000 then
        table.remove(summary.values, 1)
    end
    
    set_metrics_data("summary", summaries)
end

-- Get all metrics in Prometheus format
function _M.get_prometheus_metrics()
    init_metrics()
    local output = {}
    
    -- Counters
    local counters = get_metrics_data("counter")
    for key, metric in pairs(counters) do
        local labels_str = ""
        if next(metric.labels) then
            local label_parts = {}
            for k, v in pairs(metric.labels) do
                table.insert(label_parts, k .. '="' .. v .. '"')
            end
            labels_str = "{" .. table.concat(label_parts, ",") .. "}"
        end
        table.insert(output, "# TYPE " .. metric.name .. " counter")
        table.insert(output, metric.name .. labels_str .. " " .. metric.value)
    end
    
    -- Gauges
    local gauges = get_metrics_data("gauge")
    for key, metric in pairs(gauges) do
        local labels_str = ""
        if next(metric.labels) then
            local label_parts = {}
            for k, v in pairs(metric.labels) do
                table.insert(label_parts, k .. '="' .. v .. '"')
            end
            labels_str = "{" .. table.concat(label_parts, ",") .. "}"
        end
        table.insert(output, "# TYPE " .. metric.name .. " gauge")
        table.insert(output, metric.name .. labels_str .. " " .. metric.value)
    end
    
    -- Histograms
    local histograms = get_metrics_data("histogram")
    for key, metric in pairs(histograms) do
        local labels_str = ""
        if next(metric.labels) then
            local label_parts = {}
            for k, v in pairs(metric.labels) do
                table.insert(label_parts, k .. '="' .. v .. '"')
            end
            labels_str = "{" .. table.concat(label_parts, ",") .. "}"
        end
        
        table.insert(output, "# TYPE " .. metric.name .. " histogram")
        table.insert(output, metric.name .. "_sum" .. labels_str .. " " .. metric.sum)
        table.insert(output, metric.name .. "_count" .. labels_str .. " " .. metric.count)
        
        for i, bucket in ipairs(metric.buckets) do
            local bucket_labels = labels_str .. ',le="' .. bucket .. '"'
            table.insert(output, metric.name .. "_bucket" .. bucket_labels .. " " .. (metric.counts[i] or 0))
        end
    end
    
    -- Summaries
    local summaries = get_metrics_data("summary")
    for key, metric in pairs(summaries) do
        local labels_str = ""
        if next(metric.labels) then
            local label_parts = {}
            for k, v in pairs(metric.labels) do
                table.insert(label_parts, k .. '="' .. v .. '"')
            end
            labels_str = "{" .. table.concat(label_parts, ",") .. "}"
        end
        
        table.insert(output, "# TYPE " .. metric.name .. " summary")
        table.insert(output, metric.name .. "_sum" .. labels_str .. " " .. metric.sum)
        table.insert(output, metric.name .. "_count" .. labels_str .. " " .. metric.count)
        
        -- Calculate quantiles
        if #metric.values > 0 then
            table.sort(metric.values)
            for _, quantile in ipairs(metric.quantiles) do
                local index = math.ceil(quantile * #metric.values)
                local value = metric.values[index] or metric.values[#metric.values]
                local quantile_labels = labels_str .. ',quantile="' .. quantile .. '"'
                table.insert(output, metric.name .. quantile_labels .. " " .. value)
            end
        end
    end
    
    return table.concat(output, "\n")
end

return _M

-- /usr/local/openresty/nginx/lua/request_metrics.lua
local _M = {}
local metrics = require "metrics"
local ngx = require "ngx"

-- Track request metrics
function _M.track_request()
    local start_time = ngx.now()
    local method = ngx.var.request_method
    local uri = ngx.var.request_uri
    local status = ngx.status
    local bytes_sent = ngx.var.bytes_sent
    
    -- Increment request counter
    metrics.counter("http_requests_total", 1, {
        method = method,
        uri = uri,
        status = status
    })
    
    -- Track request duration
    local duration = ngx.now() - start_time
    metrics.histogram("http_request_duration_seconds", duration, {
        method = method,
        uri = uri
    })
    
    -- Track response size
    metrics.histogram("http_response_size_bytes", bytes_sent, {
        method = method,
        uri = uri
    })
    
    -- Track active connections
    metrics.gauge("http_active_connections", ngx.var.connections_active)
    
    -- Track request rate
    metrics.counter("http_requests_rate", 1)
end

-- Track upstream metrics
function _M.track_upstream(upstream_name, upstream_addr, response_time, status)
    metrics.counter("upstream_requests_total", 1, {
        upstream = upstream_name,
        server = upstream_addr,
        status = status
    })
    
    metrics.histogram("upstream_response_time_seconds", response_time, {
        upstream = upstream_name,
        server = upstream_addr
    })
end

-- Track cache metrics
function _M.track_cache(cache_status, cache_key)
    metrics.counter("cache_requests_total", 1, {
        status = cache_status,
        key = cache_key
    })
end

-- Track error metrics
function _M.track_error(error_type, error_message)
    metrics.counter("errors_total", 1, {
        type = error_type,
        message = error_message
    })
end

return _M

-- /usr/local/openresty/nginx/lua/system_metrics.lua
local _M = {}
local metrics = require "metrics"
local ngx = require "ngx"

-- Track system metrics
function _M.collect_system_metrics()
    -- CPU usage
    local cpu_usage = ngx.var.cpu_usage or 0
    metrics.gauge("system_cpu_usage_percent", cpu_usage)
    
    -- Memory usage
    local memory_usage = ngx.var.memory_usage or 0
    metrics.gauge("system_memory_usage_bytes", memory_usage)
    
    -- Disk usage
    local disk_usage = ngx.var.disk_usage or 0
    metrics.gauge("system_disk_usage_bytes", disk_usage)
    
    -- Network metrics
    local bytes_in = ngx.var.bytes_in or 0
    local bytes_out = ngx.var.bytes_out or 0
    metrics.counter("system_network_bytes_in_total", bytes_in)
    metrics.counter("system_network_bytes_out_total", bytes_out)
    
    -- Nginx worker metrics
    metrics.gauge("nginx_worker_processes", ngx.var.worker_processes)
    metrics.gauge("nginx_worker_connections", ngx.var.worker_connections)
    metrics.gauge("nginx_active_connections", ngx.var.connections_active)
    metrics.gauge("nginx_reading_connections", ngx.var.connections_reading)
    metrics.gauge("nginx_writing_connections", ngx.var.connections_writing)
    metrics.gauge("nginx_waiting_connections", ngx.var.connections_waiting)
    
    -- Request metrics
    metrics.counter("nginx_requests_total", ngx.var.requests_total)
    metrics.counter("nginx_requests_per_second", ngx.var.requests_per_second)
end

-- Track Lua VM metrics
function _M.collect_lua_metrics()
    -- Lua memory usage
    local lua_memory = collectgarbage("count") * 1024 -- Convert to bytes
    metrics.gauge("lua_memory_usage_bytes", lua_memory)
    
    -- Lua GC metrics
    local gc_count = collectgarbage("count")
    metrics.gauge("lua_gc_count", gc_count)
    
    -- Lua shared dict metrics
    local shared_dict_usage = ngx.shared.metrics:capacity()
    metrics.gauge("lua_shared_dict_usage_bytes", shared_dict_usage)
end

return _M

-- /usr/local/openresty/nginx/lua/business_metrics.lua
local _M = {}
local metrics = require "metrics"
local ngx = require "ngx"

-- Track user authentication
function _M.track_auth(user_id, success, method)
    metrics.counter("auth_attempts_total", 1, {
        user_id = user_id,
        success = tostring(success),
        method = method
    })
    
    if not success then
        metrics.counter("auth_failures_total", 1, {
            user_id = user_id,
            method = method
        })
    end
end

-- Track API usage
function _M.track_api_usage(api_key, endpoint, method, status)
    metrics.counter("api_requests_total", 1, {
        api_key = api_key,
        endpoint = endpoint,
        method = method,
        status = status
    })
    
    -- Track rate limiting
    if status == 429 then
        metrics.counter("api_rate_limited_total", 1, {
            api_key = api_key,
            endpoint = endpoint
        })
    end
end

-- Track payment processing
function _M.track_payment(amount, currency, status, payment_method)
    metrics.counter("payments_total", 1, {
        currency = currency,
        status = status,
        method = payment_method
    })
    
    metrics.histogram("payment_amount", amount, {
        currency = currency,
        status = status
    })
end

-- Track user activity
function _M.track_user_activity(user_id, action, resource)
    metrics.counter("user_activity_total", 1, {
        user_id = user_id,
        action = action,
        resource = resource
    })
end

return _M

-- /usr/local/openresty/nginx/lua/performance_metrics.lua
local _M = {}
local metrics = require "metrics"
local ngx = require "ngx"

-- Track response time percentiles
function _M.track_response_time(uri, method, duration)
    metrics.histogram("response_time_seconds", duration, {
        uri = uri,
        method = method
    })
    
    -- Track slow requests
    if duration > 1.0 then
        metrics.counter("slow_requests_total", 1, {
            uri = uri,
            method = method
        })
    end
end

-- Track cache hit ratio
function _M.track_cache_performance(cache_name, hit)
    metrics.counter("cache_requests_total", 1, {
        cache = cache_name,
        hit = tostring(hit)
    })
    
    if hit then
        metrics.counter("cache_hits_total", 1, {
            cache = cache_name
        })
    else
        metrics.counter("cache_misses_total", 1, {
            cache = cache_name
        })
    end
end

-- Track database performance
function _M.track_database_query(query_type, duration, success)
    metrics.histogram("database_query_duration_seconds", duration, {
        query_type = query_type,
        success = tostring(success)
    })
    
    metrics.counter("database_queries_total", 1, {
        query_type = query_type,
        success = tostring(success)
    })
end

-- Track external API calls
function _M.track_external_api(service_name, endpoint, duration, status)
    metrics.histogram("external_api_duration_seconds", duration, {
        service = service_name,
        endpoint = endpoint,
        status = status
    })
    
    metrics.counter("external_api_requests_total", 1, {
        service = service_name,
        endpoint = endpoint,
        status = status
    })
end

return _M

-- /usr/local/openresty/nginx/lua/security_metrics.lua
local _M = {}
local metrics = require "metrics"
local ngx = require "ngx"

-- Track security events
function _M.track_security_event(event_type, severity, source_ip, details)
    metrics.counter("security_events_total", 1, {
        type = event_type,
        severity = severity,
        source_ip = source_ip
    })
    
    -- Track by severity
    if severity == "high" then
        metrics.counter("security_events_high_total", 1, {
            type = event_type,
            source_ip = source_ip
        })
    end
end

-- Track failed login attempts
function _M.track_failed_login(username, source_ip, user_agent)
    metrics.counter("failed_logins_total", 1, {
        username = username,
        source_ip = source_ip
    })
    
    -- Track potential brute force
    metrics.counter("failed_logins_by_ip_total", 1, {
        source_ip = source_ip
    })
end

-- Track suspicious activity
function _M.track_suspicious_activity(activity_type, source_ip, details)
    metrics.counter("suspicious_activity_total", 1, {
        type = activity_type,
        source_ip = source_ip
    })
end

-- Track rate limiting
function _M.track_rate_limit(limit_type, source_ip, endpoint)
    metrics.counter("rate_limit_hits_total", 1, {
        type = limit_type,
        source_ip = source_ip,
        endpoint = endpoint
    })
end

return _M

-- /usr/local/openresty/nginx/lua/dashboard.lua
local _M = {}
local cjson = require "cjson"
local metrics = require "metrics"

-- Get real-time metrics
function _M.get_realtime_metrics()
    local counters = metrics.get_metrics_data("counter")
    local gauges = metrics.get_metrics_data("gauge")
    local histograms = metrics.get_metrics_data("histogram")
    
    local realtime_data = {
        timestamp = ngx.time(),
        counters = counters,
        gauges = gauges,
        histograms = histograms,
        system = {
            cpu_usage = ngx.var.cpu_usage or 0,
            memory_usage = ngx.var.memory_usage or 0,
            active_connections = ngx.var.connections_active or 0,
            requests_per_second = ngx.var.requests_per_second or 0
        }
    }
    
    return cjson.encode(realtime_data)
end

-- Get health status
function _M.get_health_status()
    local health = {
        status = "healthy",
        timestamp = ngx.time(),
        checks = {}
    }
    
    -- Check memory usage
    local memory_usage = ngx.var.memory_usage or 0
    if memory_usage > 80 then
        health.status = "unhealthy"
        health.checks.memory = "high_usage"
    else
        health.checks.memory = "ok"
    end
    
    -- Check CPU usage
    local cpu_usage = ngx.var.cpu_usage or 0
    if cpu_usage > 90 then
        health.status = "unhealthy"
        health.checks.cpu = "high_usage"
    else
        health.checks.cpu = "ok"
    end
    
    -- Check active connections
    local active_connections = ngx.var.connections_active or 0
    if active_connections > 1000 then
        health.status = "degraded"
        health.checks.connections = "high_load"
    else
        health.checks.connections = "ok"
    end
    
    return cjson.encode(health)
end

return _M

-- /usr/local/openresty/nginx/lua/auth.lua
local _M = {}
local cjson = require "cjson"
local metrics = require "metrics"
local business_metrics = require "business_metrics"

-- JWT token validation
function _M.validate_jwt(token)
    local jwt = require "resty.jwt"
    local jwt_obj = jwt:verify("your-secret-key", token)
    
    if jwt_obj.valid then
        return jwt_obj.payload
    else
        return nil
    end
end

-- API key validation
function _M.validate_api_key(api_key)
    -- Check against database or cache
    local cache = ngx.shared.cache
    local user_data = cache:get("api_key:" .. api_key)
    
    if user_data then
        return cjson.decode(user_data)
    end
    
    -- Validate against external service
    local http = require "resty.http"
    local httpc = http.new()
    local res, err = httpc:request_uri("http://auth-service/validate", {
        method = "POST",
        body = cjson.encode({api_key = api_key}),
        headers = {
            ["Content-Type"] = "application/json"
        }
    })
    
    if res and res.status == 200 then
        local user_data = cjson.decode(res.body)
        cache:set("api_key:" .. api_key, res.body, 300) -- Cache for 5 minutes
        return user_data
    end
    
    return nil
end

-- Rate limiting per user
function _M.check_rate_limit(user_id, endpoint)
    local cache = ngx.shared.cache
    local key = "rate_limit:" .. user_id .. ":" .. endpoint
    local current = cache:get(key) or 0
    
    if current >= 100 then -- 100 requests per minute
        business_metrics.track_api_usage(user_id, endpoint, ngx.var.request_method, 429)
        return false
    end
    
    cache:incr(key, 1)
    cache:expire(key, 60) -- 1 minute
    return true
end

-- Authorization check
function _M.check_permission(user, resource, action)
    -- Implement your authorization logic here
    if user.role == "admin" then
        return true
    end
    
    if user.role == "user" and action == "read" then
        return true
    end
    
    return false
end

return _M

-- /usr/local/openresty/nginx/lua/health_check.lua
local _M = {}
local http = require "resty.http"
local cjson = require "cjson"

-- Check backend health
function _M.check_backend_health()
    local backends = {
        "http://10.0.1.10:8080/health",
        "http://10.0.1.11:8080/health",
        "http://10.0.1.12:8080/health"
    }
    
    local healthy_count = 0
    
    for _, backend in ipairs(backends) do
        local httpc = http.new()
        local res, err = httpc:request_uri(backend, {
            method = "GET",
            timeout = 1000, -- 1 second timeout
            headers = {
                ["User-Agent"] = "OpenResty-HealthCheck/1.0"
            }
        })
        
        if res and res.status == 200 then
            healthy_count = healthy_count + 1
        end
    end
    
    return healthy_count > 0
end

-- Check database connectivity
function _M.check_database()
    -- Implement database health check
    return true
end

-- Check external services
function _M.check_external_services()
    local services = {
        "http://auth-service/health",
        "http://payment-service/health",
        "http://notification-service/health"
    }
    
    local healthy_count = 0
    
    for _, service in ipairs(services) do
        local httpc = http.new()
        local res, err = httpc:request_uri(service, {
            method = "GET",
            timeout = 2000, -- 2 second timeout
        })
        
        if res and res.status == 200 then
            healthy_count = healthy_count + 1
        end
    end
    
    return healthy_count >= #services * 0.8 -- 80% of services must be healthy
end

-- Comprehensive health check
function _M.comprehensive_health_check()
    local health = {
        status = "healthy",
        timestamp = ngx.time(),
        checks = {}
    }
    
    -- Check backend
    health.checks.backend = _M.check_backend_health()
    
    -- Check database
    health.checks.database = _M.check_database()
    
    -- Check external services
    health.checks.external_services = _M.check_external_services()
    
    -- Determine overall health
    if not health.checks.backend or not health.checks.database then
        health.status = "unhealthy"
    elseif not health.checks.external_services then
        health.status = "degraded"
    end
    
    return health
end

return _M

-- /usr/local/openresty/nginx/lua/memory_monitor.lua
local _M = {}

function _M.check_memory_usage()
    local memory_usage = collectgarbage("count") * 1024
    local max_memory = 100 * 1024 * 1024 -- 100MB limit
    
    if memory_usage > max_memory then
        ngx.log(ngx.WARN, "High memory usage: " .. memory_usage .. " bytes")
        collectgarbage("collect")
    end
    
    return memory_usage
end

function _M.optimize_memory()
    -- Force garbage collection
    collectgarbage("collect")
    
    -- Clear shared dictionaries if needed
    local shared_metrics = ngx.shared.metrics
    local capacity = shared_metrics:capacity()
    local free_space = shared_metrics:free_space()
    
    if free_space < capacity * 0.1 then -- Less than 10% free
        ngx.log(ngx.WARN, "Shared dictionary nearly full, clearing old data")
        -- Implement cleanup logic here
    end
end

return _M

-- /usr/local/openresty/nginx/lua/debug.lua
local _M = {}

function _M.log_debug(message, data)
    if ngx.var.debug_mode == "1" then
        local log_data = {
            timestamp = ngx.time(),
            message = message,
            data = data,
            request_id = ngx.var.request_id
        }
        ngx.log(ngx.INFO, "DEBUG: " .. cjson.encode(log_data))
    end
end

function _M.trace_function(func_name, args)
    if ngx.var.debug_mode == "1" then
        ngx.log(ngx.INFO, "TRACE: " .. func_name .. " called with args: " .. cjson.encode(args))
    end
end

function _M.measure_time(func_name, func)
    local start_time = ngx.now()
    local result = func()
    local end_time = ngx.now()
    
    ngx.log(ngx.INFO, "TIMING: " .. func_name .. " took " .. (end_time - start_time) .. " seconds")
    return result
end

return _M

-- /usr/local/openresty/nginx/lua/performance.lua
local _M = {}

-- Cache frequently used modules
local cjson = require "cjson"
local ngx = require "ngx"

-- Pre-compile regex patterns
local patterns = {
    email = ngx.re.compile("^[%w._%+-]+@[%w._%+-]+%.%w+$"),
    ipv4 = ngx.re.compile("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"),
    uuid = ngx.re.compile("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
}

-- Optimize JSON operations
function _M.fast_json_encode(data)
    return cjson.encode(data)
end

function _M.fast_json_decode(json_string)
    return cjson.decode(json_string)
end

-- Optimize string operations
function _M.fast_string_operations()
    local str = "Hello, World!"
    
    -- Use ngx.re for regex operations
    local match = ngx.re.match(str, "Hello")
    
    -- Use string methods efficiently
    local upper = string.upper(str)
    local lower = string.lower(str)
    
    return match, upper, lower
end

-- Optimize table operations
function _M.optimize_table_operations()
    local t = {}
    
    -- Pre-allocate table size if known
    local size = 1000
    for i = 1, size do
        t[i] = i
    end
    
    -- Use table.concat for string concatenation
    local result = table.concat(t, ",")
    
    return result
end

-- Memory optimization
function _M.optimize_memory()
    -- Use local variables
    local local_var = "local value"
    
    -- Avoid global variables
    -- Use ngx.shared for persistent data
    
    -- Clean up large tables
    local large_table = {}
    -- ... use large_table
    large_table = nil
    collectgarbage("collect")
end

return _M