E11y - Easy Telemetry

# Production logs right now:
[DEBUG] Cache read: session:abc123        ← 99% useless
[DEBUG] SQL: SELECT * FROM users WHERE... ← 99% useless  
[DEBUG] Rendered users/show.html.erb     ← 99% useless
[INFO] User 123 logged in                ← maybe useful
[DEBUG] Cache read: user:123              ← 99% useless
[ERROR] Payment failed: Stripe timeout    ← THIS is what you need!

# E11y buffers debug logs in memory during request
# Flushes to storage ONLY if request fails

# Happy path (99% of requests):
[INFO] User 123 logged in ✅
# Debug logs discarded, zero noise

# Error path (1% of requests):  
[ERROR] Payment failed: Stripe timeout
[DEBUG] Cache read: session:abc123      ← NOW we see the context!
[DEBUG] SQL: SELECT * FROM users...      ← NOW we see what happened!
[DEBUG] Rendered users/show.html.erb    ← Complete error trail!

# 1. Configure once
E11y.configure do |config|
  config.ephemeral_buffer_enabled = true
  config.adapters[:logs] = E11y::Adapters::Loki.new(url: ENV["LOKI_URL"])
end

# 2. Define a business event
class OrderPaidEvent < E11y::Event::Base
  schema do
    required(:order_id).filled(:string)
    required(:amount).filled(:float, gt?: 0)
    required(:currency).filled(:string, included_in?: %w[USD EUR GBP])
    optional(:user_email).maybe(:string)
  end

  validation_mode :sampled, sample_rate: 0.01   # 1% validation for hot path
  contains_pii true
  pii_filtering { hashes :user_email }
  sample_by_value :amount, greater_than: 1000  # Always sample large orders

  metrics do
    counter :orders_total, tags: [:currency]
    histogram :order_amount, value: :amount, tags: [:currency]
  end
end

# 3. Track it
OrderPaidEvent.track(order_id: "123", amount: 99.99, currency: "USD")

# Traditional approach:
Rails.logger.debug "query: SELECT..." # → Always written to disk
Rails.logger.debug "cache miss"       # → Always written to disk
Rails.logger.debug "rendering view"   # → Always written to disk
# Cost: $$$, Noise: 99%, Value: 1%

# E11y approach:
E11y.configure do |config|
  config.ephemeral_buffer_enabled = true
end

# Debug events buffered in memory during request
# Flushed to storage ONLY on 5xx server errors
# Cost: -90%, Noise: -99%, Value: 100%

class OrderPaidEvent < E11y::Event::Base
  schema do
    required(:order_id).filled(:string)
    required(:amount).filled(:float, gt?: 0)
    required(:currency).filled(:string, included_in?: %w[USD EUR GBP])
  end
  
  metrics do
    counter :orders_total, tags: [:currency]
    histogram :order_amount, value: :amount, tags: [:currency]
  end
end

# Invalid data caught BEFORE production
OrderPaidEvent.track(order_id: "123", amount: -10, currency: "INVALID")
# => E11y::ValidationError: amount must be > 0

# Valid data: event + metrics in one call
OrderPaidEvent.track(order_id: "123", amount: 99.99, currency: "USD")
# ✅ Event sent to Loki/Sentry
# ✅ Prometheus metrics updated
# ✅ No manual Yabeda.increment

# Enable Rails instrumentation
E11y.configure do |config|
  config.rails_instrumentation_enabled = true
end

# That's it! E11y now emits SLO metrics automatically:
# - HTTP endpoints: success rate, latency percentiles (p50, p95, p99)
# - Background jobs: success rate, execution time, retry rate
# - Database queries: slow query detection
# - Cache operations: hit/miss ratios
#
# SLO metrics are collected via Prometheus/Yabeda; calculate SLOs from those metrics.

# Fast setup, not 2-week OpenTelemetry migration
gem "e11y"

E11y.configure do |config|
  config.adapters[:logs] = E11y::Adapters::Loki.new(url: ENV["LOKI_URL"])
  config.adapters[:errors_tracker] = E11y::Adapters::Sentry.new(dsn: ENV["SENTRY_DSN"])

  # ActiveSupport::Notifications → E11y (HTTP, DB, cache, job lifecycle, etc.)
  config.rails_instrumentation_enabled = true

  # Optional: Sidekiq client/server middleware (buffer + job events) — enable if you use Sidekiq
  config.sidekiq_enabled = true

  # Optional: ActiveJob callbacks (buffer + context) — enable if you use Active Job
  config.active_job_enabled = true

  # Optional: wrap Rails.logger and emit E11y::Events::Rails::Log::* — opt-in
  # config.logger_bridge_enabled = true
end

class Events::UserSignedIn < E11y::Event::Base
  contains_pii :email, strategy: :hash
  contains_pii :ip_address, strategy: :mask
end

# config/initializers/e11y.rb
E11y.configure do |config|
  # Enable request-scoped debug buffering (THE killer feature)
  config.ephemeral_buffer_enabled        = true
  # config.ephemeral_buffer_flush_on_error    = true   # default: flush on 5xx
  # config.ephemeral_buffer_flush_on_statuses = [403]  # also flush on 403
  
  # Configure where events go
  config.adapters[:logs] = E11y::Adapters::Loki.new(
    url: ENV["LOKI_URL"],
    batch_size: 100
  )
  
  config.adapters[:errors_tracker] = E11y::Adapters::Sentry.new(
    dsn: ENV["SENTRY_DSN"]
  )
  
  # ActiveSupport::Notifications → E11y (see docs/RAILS_INTEGRATION.md)
  config.rails_instrumentation_enabled = true

  # Optional: Sidekiq / ActiveJob (ephemeral buffer + instrumentation at job boundaries)
  config.sidekiq_enabled = true    # set if you use Sidekiq
  config.active_job_enabled = true # set if you use Active Job (in addition or instead)

  # Optional: send Rails.logger lines into E11y as structured events
  # config.logger_bridge_enabled = true
  # config.logger_bridge_track_severities = [:warn, :error, :fatal] # nil = all severities
  # config.logger_bridge_ignore_patterns = [%r{\A\[ActiveJob\]}]
end

# app/events/order_paid_event.rb
class OrderPaidEvent < E11y::Event::Base
  # Schema validation (catch bugs before production)
  schema do
    required(:order_id).filled(:string)
    required(:amount).filled(:float, gt?: 0)
    required(:currency).filled(:string, included_in?: %w[USD EUR GBP])
  end
  
  # Auto-metrics (no manual Yabeda.increment!)
  metrics do
    counter :orders_total, tags: [:currency]
    histogram :order_amount, value: :amount, tags: [:currency]
  end
end

# In controllers/services
class OrdersController < ApplicationController
  def create
    order = Order.create!(order_params)
    
    # One method call = validation + event + metrics
    OrderPaidEvent.track(
      order_id: order.id,
      amount: order.total,
      currency: "USD"
    )
    
    # If amount is negative → E11y::ValidationError (caught before production!)
    # If valid → event sent to Loki + orders_total metric incremented
  end
end

# Development: Debug enabled
Rails.logger.debug "Cache read: session:abc"
Rails.logger.debug "SQL: SELECT * FROM users..."
Rails.logger.debug "Rendered users/show"
# Result: Helpful for debugging ✅

# Production: Debug disabled (too noisy)
Rails.logger.info "User logged in"
# Bug happens...
Rails.logger.error "Payment failed!"
# Result: No context, blind debugging ❌

# Production: Debug enabled (to catch bug)
# 99 successful requests:
#   [DEBUG] Cache read... (297 lines)
#   [INFO] User logged in (99 lines)
# 1 failed request:
#   [DEBUG] Cache read... (3 lines)
#   [ERROR] Payment failed (1 line)
# Total: 400 lines, 74% noise ❌
# Cost: High (all logs stored) ❌
# Search time: 30 seconds ❌

# Production with E11y:
E11y.configure { |c| c.ephemeral_buffer_enabled = true }

# 99 successful requests:
#   [INFO] User logged in (99 lines)
# Debug logs buffered in memory, discarded ✅

# 1 failed request:
#   [ERROR] Payment failed (1 line)
#   [DEBUG] Cache read... (3 lines) ← Flushed!
#   [DEBUG] SQL: SELECT... (context!) ← Flushed!
#   [DEBUG] Rendered view... (trail!) ← Flushed!
# Total: 103 lines, 0% noise ✅
# Cost: Low (-90% log volume) ✅
# Search time: 3 seconds ✅ (-90%)