rapitapir 0.1.0

data/examples/observability/advanced_setup.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require 'rapitapir'
+require 'rack'
+
+# Advanced observability configuration
+RapiTapir.configure do |config|
+  # Comprehensive metrics setup
+  config.metrics.enable_prometheus(
+    namespace: 'ecommerce_api',
+    labels: {
+      service: 'order_service',
+      version: ENV.fetch('APP_VERSION', '1.0.0'),
+      environment: ENV.fetch('RAILS_ENV', 'development')
+    }
+  )
+
+  # Detailed tracing configuration
+  config.tracing.enable_opentelemetry(
+    service_name: 'ecommerce-order-api',
+    service_version: ENV.fetch('APP_VERSION', '1.0.0')
+  )
+
+  # Structured logging with custom fields
+  config.logging.enable_structured(
+    level: :info,
+    fields: %i[
+      timestamp level message request_id
+      method path status duration
+      user_id tenant_id trace_id span_id
+    ]
+  )
+
+  # Comprehensive health checks
+  config.health_check.enable(endpoint: '/health')
+
+  # Database health check
+  config.health_check.add_check(:database) do
+    # Simulate database connection check
+    start_time = Time.now
+    # ActiveRecord::Base.connection.execute("SELECT 1")
+    duration = Time.now - start_time
+
+    {
+      status: :healthy,
+      message: 'Database connection successful',
+      response_time_ms: (duration * 1000).round(2)
+    }
+  rescue StandardError => e
+    {
+      status: :unhealthy,
+      message: "Database connection failed: #{e.message}"
+    }
+  end
+
+  # Redis health check
+  config.health_check.add_check(:redis) do
+    # Simulate Redis connection check
+    start_time = Time.now
+    # Redis.current.ping
+    duration = Time.now - start_time
+
+    {
+      status: :healthy,
+      message: 'Redis connection successful',
+      response_time_ms: (duration * 1000).round(2)
+    }
+  rescue StandardError => e
+    {
+      status: :unhealthy,
+      message: "Redis connection failed: #{e.message}"
+    }
+  end
+
+  # External API health check
+  config.health_check.add_check(:payment_gateway) do
+    # Simulate external API health check
+    start_time = Time.now
+    # HTTP.get("https://api.stripe.com/v1/charges", headers: { "Authorization" => "Bearer sk_test_..." })
+    duration = Time.now - start_time
+
+    if duration > 5.0 # More than 5 seconds is concerning
+      {
+        status: :warning,
+        message: 'Payment gateway responding slowly',
+        response_time_ms: (duration * 1000).round(2)
+      }
+    else
+      {
+        status: :healthy,
+        message: 'Payment gateway connection successful',
+        response_time_ms: (duration * 1000).round(2)
+      }
+    end
+  rescue StandardError => e
+    {
+      status: :unhealthy,
+      message: "Payment gateway unreachable: #{e.message}"
+    }
+  end
+end
+
+# Define order schema
+ORDER_SCHEMA = {
+  customer_id: :uuid,
+  items: [{
+    product_id: :uuid,
+    quantity: { type: :integer, minimum: 1 },
+    price: { type: :float, minimum: 0.01 }
+  }],
+  shipping_address: {
+    street: :string,
+    city: :string,
+    state: :string,
+    zip_code: :string,
+    country: :string
+  },
+  payment_method: {
+    type: { type: :string, enum: %w[credit_card paypal bank_transfer] },
+    details: :object
+  }
+}.freeze
+
+# Create order endpoint with comprehensive observability
+RapiTapir.endpoint
+         .post
+         .in('/orders')
+         .header(:authorization, Types.string(pattern: /\ABearer .+\z/), description: 'JWT token')
+         .header(:'x-tenant-id', :uuid, description: 'Tenant identifier')
+         .json_body(ORDER_SCHEMA)
+         .out_json({
+                     id: :uuid,
+                     status: { type: :string,
+                               enum: %w[pending confirmed processing shipped delivered] },
+                     customer_id: :uuid,
+                     total_amount: :float,
+                     items: [{
+                       product_id: :uuid,
+                       quantity: :integer,
+                       unit_price: :float,
+                       total_price: :float
+                     }],
+                     created_at: :datetime,
+                     updated_at: :datetime
+                   })
+         .with_metrics('order_creation')
+         .with_tracing('POST /orders')
+         .with_logging(
+           level: :info,
+           fields: %i[customer_id order_id total_amount item_count tenant_id]
+         )
+         .description('Create a new order')
+         .tag('orders')
+         .handle do |request|
+  # Extract context from headers
+  tenant_id = request.headers[:'x-tenant-id']
+  request.headers[:authorization]
+
+  # Add context to tracing
+  RapiTapir::Observability::Tracing.set_attribute('tenant.id', tenant_id)
+  RapiTapir::Observability::Tracing.set_attribute('auth.type', 'bearer')
+
+  order_data = request.body
+  customer_id = order_data[:customer_id]
+  total_amount = calculate_total_amount(order_data[:items])
+  item_count = order_data[:items].length
+
+  # Add business metrics to tracing
+  RapiTapir::Observability::Tracing.set_attribute('order.customer_id', customer_id)
+  RapiTapir::Observability::Tracing.set_attribute('order.total_amount', total_amount)
+  RapiTapir::Observability::Tracing.set_attribute('order.item_count', item_count)
+
+  # Structured logging
+  RapiTapir::Observability::Logging.info(
+    'Processing order creation',
+    customer_id: customer_id,
+    total_amount: total_amount,
+    item_count: item_count,
+    tenant_id: tenant_id
+  )
+
+  begin
+    # Simulate order processing with nested spans
+    order_id = RapiTapir::Observability::Tracing.start_span('validate_order') do
+      # Validation logic
+      validate_order(order_data)
+      SecureRandom.uuid
+    end
+
+    RapiTapir::Observability::Tracing.start_span('process_payment') do |span|
+      span.set_attribute('payment.method', order_data[:payment_method][:type])
+      span.set_attribute('payment.amount', total_amount)
+
+      # Simulate payment processing
+      payment_result = process_payment(order_data[:payment_method], total_amount)
+      span.set_attribute('payment.transaction_id', payment_result[:transaction_id])
+
+      # Add payment event
+      RapiTapir::Observability::Tracing.add_event(
+        'payment.processed',
+        attributes: {
+          'payment.status' => payment_result[:status],
+          'payment.transaction_id' => payment_result[:transaction_id]
+        }
+      )
+    end
+
+    # Build response
+    response = {
+      id: order_id,
+      status: 'confirmed',
+      customer_id: customer_id,
+      total_amount: total_amount,
+      items: order_data[:items].map.with_index do |item, _index|
+        {
+          product_id: item[:product_id],
+          quantity: item[:quantity],
+          unit_price: item[:price],
+          total_price: item[:quantity] * item[:price]
+        }
+      end,
+      created_at: Time.now.utc.iso8601,
+      updated_at: Time.now.utc.iso8601
+    }
+
+    # Success event
+    RapiTapir::Observability::Tracing.add_event(
+      'order.created',
+      attributes: {
+        'order.id' => order_id,
+        'order.status' => 'confirmed'
+      }
+    )
+
+    # Success log
+    RapiTapir::Observability::Logging.info(
+      'Order created successfully',
+      customer_id: customer_id,
+      order_id: order_id,
+      total_amount: total_amount,
+      item_count: item_count,
+      tenant_id: tenant_id
+    )
+
+    response
+  rescue ValidationError => e
+    RapiTapir::Observability::Tracing.record_exception(e)
+    RapiTapir::Observability::Logging.log_error(
+      e,
+      customer_id: customer_id,
+      operation: 'order_validation',
+      tenant_id: tenant_id
+    )
+    raise
+  rescue PaymentError => e
+    RapiTapir::Observability::Tracing.record_exception(e)
+    RapiTapir::Observability::Logging.log_error(
+      e,
+      customer_id: customer_id,
+      operation: 'payment_processing',
+      tenant_id: tenant_id,
+      total_amount: total_amount
+    )
+    raise
+  rescue StandardError => e
+    RapiTapir::Observability::Tracing.record_exception(e)
+    RapiTapir::Observability::Logging.log_error(
+      e,
+      customer_id: customer_id,
+      operation: 'order_creation',
+      tenant_id: tenant_id
+    )
+    raise
+  end
+end
+
+# Helper methods for the example
+def calculate_total_amount(items)
+  items.sum { |item| item[:quantity] * item[:price] }
+end
+
+def validate_order(order_data)
+  # Simulation of order validation
+  raise ValidationError, 'Invalid customer ID' if order_data[:customer_id].nil?
+  raise ValidationError, 'No items in order' if order_data[:items].empty?
+
+  order_data[:items].each do |item|
+    raise ValidationError, 'Invalid item quantity' if item[:quantity] <= 0
+    raise ValidationError, 'Invalid item price' if item[:price] <= 0
+  end
+end
+
+def process_payment(payment_method, amount)
+  # Simulation of payment processing
+  case payment_method[:type]
+  when 'credit_card'
+    # Simulate potential payment failure
+    raise PaymentError, 'Credit card declined' if amount > 10_000
+
+    {
+      status: 'success',
+      transaction_id: SecureRandom.hex(16)
+    }
+  when 'paypal'
+    {
+      status: 'success',
+      transaction_id: "PP_#{SecureRandom.hex(12)}"
+    }
+  when 'bank_transfer'
+    {
+      status: 'pending',
+      transaction_id: "BT_#{SecureRandom.hex(12)}"
+    }
+  else
+    raise PaymentError, 'Unsupported payment method'
+  end
+end
+
+# Custom exception classes
+class ValidationError < StandardError; end
+class PaymentError < StandardError; end
+
+# Rack application with observability
+class OrderApp
+  def call(env)
+    # Route to our endpoints
+    request = Rack::Request.new(env)
+
+    case request.path_info
+    when '/orders'
+      if request.request_method == 'POST'
+        create_order_endpoint.call(env)
+      else
+        [405, { 'Content-Type' => 'text/plain' }, ['Method Not Allowed']]
+      end
+    else
+      [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
+    end
+  end
+end
+
+# Build Rack app with observability middleware
+Rack::Builder.new do
+  # Add observability middleware
+  use RapiTapir::Observability::RackMiddleware
+
+  # Your application
+  run OrderApp.new
+end
+
+puts 'Advanced observability example configured!'
+puts 'Available endpoints:'
+puts '- POST /orders (create order with full observability)'
+puts '- GET /health (comprehensive health checks)'
+puts '- GET /metrics (detailed Prometheus metrics)'
+puts ''
+puts 'Example request:'
+puts 'curl -X POST http://localhost:9292/orders \\'
+puts "  -H 'Content-Type: application/json' \\"
+puts "  -H 'Authorization: Bearer your-jwt-token' \\"
+puts "  -H 'X-Tenant-ID: 123e4567-e89b-12d3-a456-426614174000' \\"
+puts "  -d '{"
+puts '    "customer_id": "123e4567-e89b-12d3-a456-426614174000",'
+puts '    "items": ['
+puts '      {'
+puts '        "product_id": "123e4567-e89b-12d3-a456-426614174001",'
+puts '        "quantity": 2,'
+puts '        "price": 29.99'
+puts '      }'
+puts '    ],'
+puts '    "shipping_address": {'
+puts '      "street": "123 Main St",'
+puts '      "city": "Anytown",'
+puts '      "state": "CA",'
+puts '      "zip_code": "12345",'
+puts '      "country": "US"'
+puts '    },'
+puts '    "payment_method": {'
+puts '      "type": "credit_card",'
+puts '      "details": {}'
+puts '    }'
+puts "  }'"
+puts ''
+puts 'To run: rackup -p 9292'

data/examples/observability/basic_setup.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'rapitapir'
+
+# Configure observability for the application
+RapiTapir.configure do |config|
+  # Enable Prometheus metrics
+  config.metrics.enable_prometheus(
+    namespace: 'my_api',
+    labels: { service: 'user_service', version: '1.0.0' }
+  )
+
+  # Enable OpenTelemetry tracing
+  config.tracing.enable_opentelemetry(
+    service_name: 'my-api-service',
+    service_version: '1.0.0'
+  )
+
+  # Enable structured logging
+  config.logging.enable_structured(
+    level: :info,
+    fields: %i[timestamp level message request_id method path status duration user_id]
+  )
+
+  # Enable health checks
+  config.health_check.enable(endpoint: '/health')
+
+  # Add custom health checks
+  config.health_check.add_check(:database) do
+    # Simulate database health check
+    { status: :healthy, message: 'Database connection OK' }
+  end
+
+  config.health_check.add_check(:redis) do
+    # Simulate Redis health check
+    { status: :healthy, message: 'Redis connection OK' }
+  end
+end
+
+# Example endpoint with observability
+RapiTapir.endpoint
+         .post
+         .in('/users')
+         .json_body({
+                      name: :string,
+                      email: :email,
+                      age: { type: :integer, minimum: 18 }
+                    })
+         .out_json({
+                     id: :uuid,
+                     name: :string,
+                     email: :email,
+                     created_at: :datetime
+                   })
+         .with_metrics('user_creation')
+         .with_tracing
+         .with_logging(level: :info, fields: %i[user_email user_age])
+         .description('Create a new user')
+         .tag('users')
+         .handle do |request|
+  # Extract user data
+  user_data = request.body
+
+  # Add custom attributes to tracing span
+  RapiTapir::Observability::Tracing.set_attribute('user.email', user_data[:email])
+  RapiTapir::Observability::Tracing.set_attribute('user.age', user_data[:age])
+
+  # Log user creation attempt
+  RapiTapir::Observability::Logging.info(
+    'Creating user',
+    user_email: user_data[:email],
+    user_age: user_data[:age]
+  )
+
+  begin
+    # Simulate user creation with metrics
+    user_id = SecureRandom.uuid
+    created_at = Time.now.utc
+
+    # Add event to tracing span
+    RapiTapir::Observability::Tracing.add_event(
+      'user.created',
+      attributes: { 'user.id' => user_id }
+    )
+
+    # Return created user
+    {
+      id: user_id,
+      name: user_data[:name],
+      email: user_data[:email],
+      created_at: created_at.iso8601
+    }
+  rescue StandardError => e
+    # Record exception in tracing
+    RapiTapir::Observability::Tracing.record_exception(e)
+
+    # Log error with structured format
+    RapiTapir::Observability::Logging.log_error(
+      e,
+      user_email: user_data[:email],
+      operation: 'user_creation'
+    )
+
+    raise
+  end
+end
+
+# Example endpoint with custom metrics
+RapiTapir.endpoint
+         .get
+         .in('/users')
+         .query(:page, Types.integer(minimum: 1, default: 1))
+         .query(:limit, Types.integer(minimum: 1, maximum: 100, default: 20))
+         .out_json({
+                     users: [{
+                       id: :uuid,
+                       name: :string,
+                       email: :email
+                     }],
+                     pagination: {
+                       current_page: :integer,
+                       total_pages: :integer,
+                       total_count: :integer
+                     }
+                   })
+         .with_metrics('user_list')
+         .with_tracing('GET /users')
+         .handle do |request|
+  page = request.query[:page] || 1
+  limit = request.query[:limit] || 20
+
+  # Custom span attributes
+  RapiTapir::Observability::Tracing.set_attribute('pagination.page', page)
+  RapiTapir::Observability::Tracing.set_attribute('pagination.limit', limit)
+
+  # Simulate fetching users
+  users = (1..limit).map do |i|
+    {
+      id: SecureRandom.uuid,
+      name: "User #{((page - 1) * limit) + i}",
+      email: "user#{((page - 1) * limit) + i}@example.com"
+    }
+  end
+
+  total_count = 1000 # Simulated total
+  total_pages = (total_count / limit.to_f).ceil
+
+  {
+    users: users,
+    pagination: {
+      current_page: page,
+      total_pages: total_pages,
+      total_count: total_count
+    }
+  }
+end
+
+# Error handling endpoint example
+RapiTapir.endpoint
+         .get
+         .in('/error-test')
+         .out_json({ error: :string })
+         .with_metrics('error_test')
+         .with_tracing
+         .handle do |request|
+  # Simulate different types of errors for testing observability
+  error_type = request.query[:type] || 'generic'
+
+  case error_type
+  when 'timeout'
+    raise Timeout::Error, 'Operation timed out'
+  when 'validation'
+    raise ArgumentError, 'Invalid input data'
+  when 'not_found'
+    raise StandardError, 'Resource not found'
+  else
+    raise 'Generic error for testing'
+  end
+end
+
+puts 'Observability example configured!'
+puts 'Available endpoints:'
+puts '- POST /users (create user with full observability)'
+puts '- GET /users (list users with pagination tracking)'
+puts '- GET /error-test (test error tracking)'
+puts '- GET /health (health check endpoint)'
+puts '- GET /metrics (Prometheus metrics endpoint)'
+puts ''
+puts 'To run with a Rack server:'
+puts "require 'rack'"
+puts 'use RapiTapir::Observability::RackMiddleware'
+puts 'run YourApp'

data/examples/observability/complete_test.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+puts "🍯 Complete Honeycomb.io Server Test"
+puts "===================================="
+
+# Change to project root
+project_root = File.expand_path('../../', __dir__)
+Dir.chdir(project_root)
+
+puts "📂 Working directory: #{Dir.pwd}"
+
+# Start server in background
+puts "📡 Starting server..."
+server_pid = spawn("bundle exec ruby examples/observability/honeycomb_working_example.rb", 
+                   out: "/tmp/honeycomb_server.log", 
+                   err: "/tmp/honeycomb_server.log")
+
+# Give server time to start
+puts "⏳ Waiting for server to start..."
+server_ready = false
+20.times do |i|
+  sleep 1
+  begin
+    response = Net::HTTP.get_response(URI('http://localhost:4567/health'))
+    if response.code == '200'
+      server_ready = true
+      puts "✅ Server is ready! (attempt #{i + 1})"
+      break
+    end
+  rescue Errno::ECONNREFUSED, Net::OpenTimeout
+    print "."
+  end
+end
+
+unless server_ready
+  puts "\n❌ Server failed to start within 20 seconds"
+  Process.kill('TERM', server_pid) rescue nil
+  Process.wait(server_pid) rescue nil
+  exit 1
+end
+
+puts "\n🧪 Running tests..."
+
+# Test 1: Health check
+puts "\n1️⃣ Testing health endpoint..."
+response = Net::HTTP.get_response(URI('http://localhost:4567/health'))
+puts "   Status: #{response.code}"
+puts "   Body: #{response.body}"
+
+# Test 2: List users (empty)
+puts "\n2️⃣ Testing user list endpoint..."
+response = Net::HTTP.get_response(URI('http://localhost:4567/users'))
+puts "   Status: #{response.code}"
+puts "   Body: #{response.body}"
+
+# Test 3: Create a user
+puts "\n3️⃣ Testing user creation..."
+uri = URI('http://localhost:4567/users')
+http = Net::HTTP.new(uri.host, uri.port)
+request = Net::HTTP::Post.new(uri)
+request['Content-Type'] = 'application/json'
+request.body = {
+  name: 'Alice Johnson',
+  email: 'alice@example.com',
+  age: 28,
+  department: 'engineering'
+}.to_json
+
+response = http.request(request)
+puts "   Status: #{response.code}"
+puts "   Body: #{response.body}"
+
+if response.code == '201'
+  user_data = JSON.parse(response.body)
+  user_id = user_data['id']
+  
+  # Test 4: Get the created user
+  puts "\n4️⃣ Testing get user by ID..."
+  response = Net::HTTP.get_response(URI("http://localhost:4567/users/#{user_id}"))
+  puts "   Status: #{response.code}"
+  puts "   Body: #{response.body}"
+  
+  # Test 5: Update the user
+  puts "\n5️⃣ Testing user update..."
+  uri = URI("http://localhost:4567/users/#{user_id}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  request = Net::HTTP::Put.new(uri)
+  request['Content-Type'] = 'application/json'
+  request.body = {
+    name: 'Alice Johnson-Smith',
+    department: 'product'
+  }.to_json
+  
+  response = http.request(request)
+  puts "   Status: #{response.code}"
+  puts "   Body: #{response.body}"
+end
+
+# Test 6: Department analytics
+puts "\n6️⃣ Testing department analytics..."
+response = Net::HTTP.get_response(URI('http://localhost:4567/analytics/department-stats'))
+puts "   Status: #{response.code}"
+puts "   Body: #{response.body}"
+
+puts "\n✅ All tests completed!"
+puts "\n📊 Check your Honeycomb.io dashboard for traces!"
+puts "   Dataset: rapitapir-demo"
+puts "   Service: rapitapir-demo"
+
+# Cleanup
+puts "\n🧹 Cleaning up..."
+Process.kill('TERM', server_pid) rescue nil
+Process.wait(server_pid) rescue nil
+puts "✅ Server stopped"
+
+puts "\n🎉 Test complete! Your Honeycomb integration is working!"