tsikol 0.1.0

data/docs/cookbook/logging.md

@@ -0,0 +1,1044 @@
+# Logging Recipe
+
+This recipe shows comprehensive logging strategies for debugging, monitoring, and auditing your MCP server.
+
+## Basic Logging
+
+### Server Logging Configuration
+
+```ruby
+Tsikol.start(name: "logged-server") do
+  # Enable logging capability
+  logging true
+  
+  # Use built-in logging middleware
+  use Tsikol::LoggingMiddleware,
+      level: :info,
+      include_params: true,
+      include_response: true,
+      max_response_length: 500
+  
+  # Custom logger configuration
+  before_start do
+    configure_logger
+  end
+  
+  tool LoggedTool
+  resource LoggedResource
+end
+
+def configure_logger
+  # Set up custom logger
+  require 'logger'
+  
+  logger = Logger.new(STDOUT)
+  logger.level = ENV['LOG_LEVEL'] || Logger::INFO
+  
+  # Custom formatter
+  logger.formatter = proc do |severity, datetime, progname, msg|
+    {
+      timestamp: datetime.iso8601,
+      level: severity,
+      program: progname,
+      message: msg,
+      pid: Process.pid,
+      thread: Thread.current.object_id
+    }.to_json + "\n"
+  end
+  
+  # Make logger available globally
+  Thread.current[:logger] = logger
+end
+```
+
+### Tool Logging
+
+```ruby
+class LoggedTool < Tsikol::Tool
+  description "Tool with comprehensive logging"
+  
+  parameter :operation do
+    type :string
+    required
+  end
+  
+  parameter :data do
+    type :object
+    required
+  end
+  
+  def execute(operation:, data:)
+    request_id = SecureRandom.uuid
+    
+    log :info, "Tool execution started",
+        request_id: request_id,
+        operation: operation,
+        data_size: data.to_json.bytesize
+    
+    start_time = Time.now
+    
+    begin
+      result = perform_operation(operation, data)
+      
+      log :info, "Tool execution completed",
+          request_id: request_id,
+          duration_ms: ((Time.now - start_time) * 1000).round(2),
+          result_size: result.to_json.bytesize
+      
+      result
+      
+    rescue => e
+      log :error, "Tool execution failed",
+          request_id: request_id,
+          duration_ms: ((Time.now - start_time) * 1000).round(2),
+          error: e.class.name,
+          message: e.message,
+          backtrace: e.backtrace&.first(5)
+      
+      raise
+    end
+  end
+  
+  private
+  
+  def perform_operation(operation, data)
+    log :debug, "Processing operation", operation: operation
+    
+    case operation
+    when "transform"
+      transform_data(data)
+    when "analyze"
+      analyze_data(data)
+    else
+      raise ArgumentError, "Unknown operation: #{operation}"
+    end
+  end
+  
+  def set_server(server)
+    @server = server
+    
+    # Set up logging if server supports it
+    if @server.logging_enabled?
+      define_singleton_method(:log) do |level, message, **data|
+        @server.log(level, "[#{self.class.name}] #{message}", data: data)
+      end
+    else
+      # No-op logging if not enabled
+      define_singleton_method(:log) do |*args|
+      end
+    end
+  end
+end
+```
+
+## Structured Logging
+
+### JSON Logger Middleware
+
+```ruby
+class StructuredLoggingMiddleware < Tsikol::Middleware
+  def initialize(app, options = {})
+    @app = app
+    @logger = options[:logger] || create_default_logger
+    @include_params = options.fetch(:include_params, true)
+    @sanitizer = options[:sanitizer] || DefaultSanitizer.new
+  end
+  
+  def call(request)
+    context = build_request_context(request)
+    
+    log_event(:request_started, context)
+    
+    start_time = Time.now
+    response = nil
+    
+    begin
+      response = @app.call(request)
+      
+      context[:response] = build_response_context(response)
+      context[:duration_ms] = ((Time.now - start_time) * 1000).round(2)
+      
+      log_event(:request_completed, context)
+      
+      response
+      
+    rescue => e
+      context[:error] = build_error_context(e)
+      context[:duration_ms] = ((Time.now - start_time) * 1000).round(2)
+      
+      log_event(:request_failed, context)
+      
+      raise
+    end
+  end
+  
+  private
+  
+  def create_default_logger
+    logger = Logger.new(STDOUT)
+    logger.formatter = JsonFormatter.new
+    logger
+  end
+  
+  def build_request_context(request)
+    context = {
+      request_id: request["id"],
+      method: request["method"],
+      timestamp: Time.now.iso8601
+    }
+    
+    if @include_params && request["params"]
+      context[:params] = @sanitizer.sanitize(request["params"])
+    end
+    
+    context
+  end
+  
+  def build_response_context(response)
+    if response[:error]
+      {
+        status: "error",
+        error_code: response[:error][:code],
+        error_message: response[:error][:message]
+      }
+    else
+      {
+        status: "success",
+        result_type: response[:result].class.name
+      }
+    end
+  end
+  
+  def build_error_context(error)
+    {
+      error_class: error.class.name,
+      error_message: error.message,
+      backtrace: error.backtrace&.first(3)
+    }
+  end
+  
+  def log_event(event, context)
+    @logger.info({
+      event: event,
+      service: "mcp-server",
+      **context
+    })
+  end
+end
+
+class JsonFormatter
+  def call(severity, timestamp, progname, msg)
+    log_entry = {
+      timestamp: timestamp.iso8601,
+      level: severity,
+      program: progname
+    }
+    
+    if msg.is_a?(Hash)
+      log_entry.merge!(msg)
+    else
+      log_entry[:message] = msg
+    end
+    
+    JSON.generate(log_entry) + "\n"
+  end
+end
+
+class DefaultSanitizer
+  SENSITIVE_KEYS = %w[password token secret key auth api_key].freeze
+  
+  def sanitize(data)
+    case data
+    when Hash
+      data.transform_values do |value|
+        if sensitive_key?(data.keys)
+          "[REDACTED]"
+        else
+          sanitize(value)
+        end
+      end
+    when Array
+      data.map { |item| sanitize(item) }
+    else
+      data
+    end
+  end
+  
+  private
+  
+  def sensitive_key?(keys)
+    keys.any? do |key|
+      SENSITIVE_KEYS.any? { |sensitive| key.to_s.downcase.include?(sensitive) }
+    end
+  end
+end
+```
+
+### Request Context Logging
+
+```ruby
+class RequestContextMiddleware < Tsikol::Middleware
+  def call(request)
+    # Set up request context for logging
+    RequestContext.with_context(
+      request_id: request["id"] || SecureRandom.uuid,
+      method: request["method"],
+      user_id: request.dig("authenticated_user", "id"),
+      client_id: request.dig("params", "_client_id"),
+      correlation_id: request.dig("params", "_correlation_id")
+    ) do
+      @app.call(request)
+    end
+  end
+end
+
+module RequestContext
+  extend self
+  
+  def with_context(context)
+    old_context = current
+    self.current = current.merge(context)
+    yield
+  ensure
+    self.current = old_context
+  end
+  
+  def current
+    Thread.current[:request_context] ||= {}
+  end
+  
+  def current=(context)
+    Thread.current[:request_context] = context
+  end
+  
+  def to_h
+    current.dup
+  end
+end
+
+# Enhanced logger that includes context
+class ContextualLogger
+  def initialize(base_logger)
+    @base_logger = base_logger
+  end
+  
+  %i[debug info warn error fatal].each do |level|
+    define_method(level) do |message, **data|
+      log_with_context(level, message, data)
+    end
+  end
+  
+  private
+  
+  def log_with_context(level, message, data)
+    context = RequestContext.to_h
+    
+    @base_logger.send(level, {
+      message: message,
+      **context,
+      **data
+    })
+  end
+end
+```
+
+## Log Aggregation
+
+### Multi-Destination Logging
+
+```ruby
+class MultiLogger
+  def initialize
+    @loggers = []
+  end
+  
+  def add_logger(logger)
+    @loggers << logger
+  end
+  
+  %i[debug info warn error fatal].each do |level|
+    define_method(level) do |message, **data|
+      @loggers.each do |logger|
+        logger.send(level, message, **data) rescue nil
+      end
+    end
+  end
+end
+
+# File logger with rotation
+file_logger = Logger.new(
+  "logs/mcp-server.log",
+  10,           # Keep 10 files
+  10_485_760    # 10MB per file
+)
+
+# Syslog logger
+require 'syslog/logger'
+syslog_logger = Syslog::Logger.new("mcp-server")
+
+# JSON logger for structured logs
+json_logger = Logger.new("logs/mcp-server.json")
+json_logger.formatter = JsonFormatter.new
+
+# CloudWatch logger (example)
+class CloudWatchLogger
+  def initialize(log_group, log_stream)
+    @client = Aws::CloudWatchLogs::Client.new
+    @log_group = log_group
+    @log_stream = log_stream
+    @buffer = []
+    @mutex = Mutex.new
+    
+    start_flush_thread
+  end
+  
+  def log(level, message, data = {})
+    event = {
+      timestamp: (Time.now.to_f * 1000).to_i,
+      message: {
+        level: level.to_s.upcase,
+        message: message,
+        **data
+      }.to_json
+    }
+    
+    @mutex.synchronize { @buffer << event }
+  end
+  
+  %i[debug info warn error fatal].each do |level|
+    define_method(level) do |message, **data|
+      log(level, message, data)
+    end
+  end
+  
+  private
+  
+  def start_flush_thread
+    Thread.new do
+      loop do
+        sleep 5
+        flush_buffer
+      end
+    end
+  end
+  
+  def flush_buffer
+    events = @mutex.synchronize do
+      @buffer.dup.tap { @buffer.clear }
+    end
+    
+    return if events.empty?
+    
+    @client.put_log_events(
+      log_group_name: @log_group,
+      log_stream_name: @log_stream,
+      log_events: events
+    )
+  rescue => e
+    # Re-add events to buffer on failure
+    @mutex.synchronize { @buffer.concat(events) }
+  end
+end
+
+# Combine all loggers
+multi_logger = MultiLogger.new
+multi_logger.add_logger(file_logger)
+multi_logger.add_logger(syslog_logger)
+multi_logger.add_logger(json_logger)
+multi_logger.add_logger(CloudWatchLogger.new("mcp-servers", "production"))
+```
+
+## Performance Logging
+
+### Request Performance Tracking
+
+```ruby
+class PerformanceLoggingMiddleware < Tsikol::Middleware
+  def initialize(app, options = {})
+    @app = app
+    @slow_request_threshold = options[:slow_request_threshold] || 1000  # ms
+    @metrics_logger = options[:metrics_logger] || create_metrics_logger
+  end
+  
+  def call(request)
+    timer = RequestTimer.new(request)
+    
+    begin
+      response = @app.call(request)
+      
+      timer.stop
+      log_performance_metrics(timer, response)
+      
+      response
+      
+    rescue => e
+      timer.stop
+      log_performance_metrics(timer, nil, e)
+      raise
+    end
+  end
+  
+  private
+  
+  def log_performance_metrics(timer, response, error = nil)
+    metrics = timer.metrics
+    
+    # Always log slow requests
+    if metrics[:total_ms] > @slow_request_threshold
+      log :warning, "Slow request detected", metrics
+    end
+    
+    # Log to metrics system
+    @metrics_logger.info({
+      event: "request_performance",
+      **metrics,
+      status: error ? "error" : "success",
+      error_class: error&.class&.name
+    })
+  end
+  
+  def create_metrics_logger
+    logger = Logger.new("logs/metrics.log")
+    logger.formatter = proc do |_, timestamp, _, msg|
+      "#{timestamp.iso8601} #{msg.to_json}\n"
+    end
+    logger
+  end
+end
+
+class RequestTimer
+  attr_reader :request, :checkpoints
+  
+  def initialize(request)
+    @request = request
+    @start_time = Time.now
+    @checkpoints = {}
+    @stopped = false
+  end
+  
+  def checkpoint(name)
+    @checkpoints[name] = Time.now unless @stopped
+  end
+  
+  def stop
+    @end_time = Time.now
+    @stopped = true
+  end
+  
+  def metrics
+    total_time = (@end_time || Time.now) - @start_time
+    
+    metrics = {
+      method: @request["method"],
+      request_id: @request["id"],
+      total_ms: (total_time * 1000).round(2),
+      timestamp: @start_time.iso8601
+    }
+    
+    # Add checkpoint timings
+    @checkpoints.each do |name, time|
+      metrics["#{name}_ms"] = ((time - @start_time) * 1000).round(2)
+    end
+    
+    metrics
+  end
+end
+```
+
+### Database Query Logging
+
+```ruby
+class QueryLogger
+  def initialize(options = {})
+    @logger = options[:logger] || create_query_logger
+    @slow_query_threshold = options[:slow_query_threshold] || 100  # ms
+    @include_binds = options[:include_binds] || false
+  end
+  
+  def log_query(sql, binds = [], &block)
+    start_time = Time.now
+    rows_affected = nil
+    
+    begin
+      result = yield
+      rows_affected = extract_rows_affected(result)
+      result
+    rescue => e
+      log_query_event(sql, binds, start_time, error: e)
+      raise
+    else
+      log_query_event(sql, binds, start_time, rows_affected: rows_affected)
+    end
+  end
+  
+  private
+  
+  def log_query_event(sql, binds, start_time, error: nil, rows_affected: nil)
+    duration_ms = ((Time.now - start_time) * 1000).round(2)
+    
+    event = {
+      event: "database_query",
+      sql: sanitize_sql(sql),
+      duration_ms: duration_ms,
+      timestamp: start_time.iso8601,
+      context: RequestContext.to_h
+    }
+    
+    event[:binds] = binds if @include_binds && binds.any?
+    event[:rows_affected] = rows_affected if rows_affected
+    event[:error] = error.message if error
+    
+    level = determine_log_level(duration_ms, error)
+    @logger.send(level, event)
+  end
+  
+  def determine_log_level(duration_ms, error)
+    return :error if error
+    return :warning if duration_ms > @slow_query_threshold
+    :debug
+  end
+  
+  def sanitize_sql(sql)
+    # Remove excess whitespace
+    sql.gsub(/\s+/, ' ').strip
+  end
+  
+  def extract_rows_affected(result)
+    case result
+    when Integer
+      result
+    when Array
+      result.size
+    else
+      nil
+    end
+  end
+  
+  def create_query_logger
+    Logger.new("logs/queries.log").tap do |logger|
+      logger.formatter = JsonFormatter.new
+    end
+  end
+end
+
+# Usage in database operations
+class DatabaseTool < Tsikol::Tool
+  def initialize
+    super
+    @query_logger = QueryLogger.new
+  end
+  
+  def execute(query:)
+    @query_logger.log_query(query) do
+      # Execute actual database query
+      Database.connection.execute(query)
+    end
+  end
+end
+```
+
+## Audit Logging
+
+### Security Audit Trail
+
+```ruby
+class AuditLogger
+  def initialize(options = {})
+    @logger = create_audit_logger(options[:log_file] || "logs/audit.log")
+    @include_ip = options[:include_ip] || true
+    @include_user_agent = options[:include_user_agent] || true
+  end
+  
+  def log_event(event_type, details = {})
+    audit_entry = build_audit_entry(event_type, details)
+    @logger.info(audit_entry)
+    
+    # Also send to security monitoring system
+    send_to_siem(audit_entry) if critical_event?(event_type)
+  end
+  
+  def log_authentication(success:, user_id: nil, method: nil, reason: nil)
+    log_event(
+      success ? :authentication_success : :authentication_failure,
+      user_id: user_id,
+      method: method,
+      reason: reason
+    )
+  end
+  
+  def log_authorization(success:, user_id:, resource:, action:, reason: nil)
+    log_event(
+      success ? :authorization_success : :authorization_failure,
+      user_id: user_id,
+      resource: resource,
+      action: action,
+      reason: reason
+    )
+  end
+  
+  def log_data_access(user_id:, resource:, operation:, data_classification: nil)
+    log_event(
+      :data_access,
+      user_id: user_id,
+      resource: resource,
+      operation: operation,
+      data_classification: data_classification
+    )
+  end
+  
+  def log_configuration_change(user_id:, setting:, old_value:, new_value:)
+    log_event(
+      :configuration_change,
+      user_id: user_id,
+      setting: setting,
+      old_value: sanitize_value(old_value),
+      new_value: sanitize_value(new_value)
+    )
+  end
+  
+  private
+  
+  def build_audit_entry(event_type, details)
+    entry = {
+      event_type: event_type,
+      timestamp: Time.now.iso8601,
+      **details,
+      **RequestContext.to_h
+    }
+    
+    # Add request metadata
+    if request = Thread.current[:mcp_request]
+      entry[:client_ip] = extract_client_ip(request) if @include_ip
+      entry[:user_agent] = request.dig("meta", "user_agent") if @include_user_agent
+    end
+    
+    entry
+  end
+  
+  def critical_event?(event_type)
+    %i[
+      authentication_failure
+      authorization_failure
+      configuration_change
+      privilege_escalation
+      data_export
+    ].include?(event_type)
+  end
+  
+  def send_to_siem(audit_entry)
+    # Send to Security Information and Event Management system
+    Thread.new do
+      SiemClient.send_event(audit_entry)
+    rescue => e
+      # Log but don't fail
+      @logger.error("Failed to send to SIEM: #{e.message}")
+    end
+  end
+  
+  def sanitize_value(value)
+    case value
+    when String
+      value.include?("password") ? "[REDACTED]" : value
+    when Hash
+      value.transform_values { |v| sanitize_value(v) }
+    else
+      value
+    end
+  end
+  
+  def create_audit_logger(log_file)
+    # Audit logs should be append-only and tamper-evident
+    Logger.new(log_file, 0, nil).tap do |logger|
+      logger.formatter = proc do |_, timestamp, _, msg|
+        # Include checksum for tamper detection
+        entry = msg.merge(timestamp: timestamp.iso8601)
+        checksum = Digest::SHA256.hexdigest(entry.to_json)
+        
+        "#{entry.to_json}|#{checksum}\n"
+      end
+    end
+  end
+end
+
+# Audit middleware
+class AuditMiddleware < Tsikol::Middleware
+  def initialize(app, options = {})
+    @app = app
+    @audit_logger = options[:audit_logger] || AuditLogger.new
+    @audit_methods = options[:audit_methods] || sensitive_methods
+  end
+  
+  def call(request)
+    if should_audit?(request)
+      audit_request(request)
+    end
+    
+    response = @app.call(request)
+    
+    if should_audit?(request)
+      audit_response(request, response)
+    end
+    
+    response
+  end
+  
+  private
+  
+  def should_audit?(request)
+    @audit_methods.include?(request["method"])
+  end
+  
+  def sensitive_methods
+    %w[
+      tools/call
+      resources/read
+      configuration/update
+      users/create
+      users/update
+      users/delete
+    ]
+  end
+  
+  def audit_request(request)
+    user_id = request.dig("authenticated_user", "id")
+    
+    @audit_logger.log_event(
+      :api_request,
+      method: request["method"],
+      user_id: user_id,
+      params: sanitize_params(request["params"])
+    )
+  end
+  
+  def audit_response(request, response)
+    if response[:error]
+      @audit_logger.log_event(
+        :api_error,
+        method: request["method"],
+        error_code: response[:error][:code],
+        error_message: response[:error][:message]
+      )
+    end
+  end
+end
+```
+
+## Log Analysis Tools
+
+### Log Parser and Analyzer
+
+```ruby
+class LogAnalyzer
+  def initialize(log_file)
+    @log_file = log_file
+  end
+  
+  def analyze_performance(time_range = nil)
+    stats = {
+      total_requests: 0,
+      slow_requests: 0,
+      errors: 0,
+      average_duration: 0,
+      percentiles: {}
+    }
+    
+    durations = []
+    
+    parse_logs(time_range) do |entry|
+      next unless entry[:event] == "request_completed"
+      
+      stats[:total_requests] += 1
+      duration = entry[:duration_ms]
+      durations << duration
+      
+      stats[:slow_requests] += 1 if duration > 1000
+      stats[:errors] += 1 if entry[:status] == "error"
+    end
+    
+    if durations.any?
+      stats[:average_duration] = (durations.sum / durations.size).round(2)
+      stats[:percentiles] = calculate_percentiles(durations)
+    end
+    
+    stats
+  end
+  
+  def find_errors(time_range = nil)
+    errors = []
+    
+    parse_logs(time_range) do |entry|
+      if entry[:level] == "ERROR" || entry[:event] == "request_failed"
+        errors << {
+          timestamp: entry[:timestamp],
+          error: entry[:error_message] || entry[:message],
+          method: entry[:method],
+          request_id: entry[:request_id]
+        }
+      end
+    end
+    
+    errors
+  end
+  
+  def trace_request(request_id)
+    entries = []
+    
+    parse_logs do |entry|
+      if entry[:request_id] == request_id
+        entries << entry
+      end
+    end
+    
+    entries.sort_by { |e| e[:timestamp] }
+  end
+  
+  private
+  
+  def parse_logs(time_range = nil)
+    File.foreach(@log_file) do |line|
+      begin
+        entry = JSON.parse(line.strip)
+        
+        if time_range
+          timestamp = Time.parse(entry["timestamp"])
+          next unless time_range.cover?(timestamp)
+        end
+        
+        yield(entry.transform_keys(&:to_sym))
+      rescue JSON::ParserError
+        # Skip malformed lines
+      end
+    end
+  end
+  
+  def calculate_percentiles(values)
+    sorted = values.sort
+    
+    {
+      p50: percentile(sorted, 0.5),
+      p90: percentile(sorted, 0.9),
+      p95: percentile(sorted, 0.95),
+      p99: percentile(sorted, 0.99)
+    }
+  end
+  
+  def percentile(sorted_values, p)
+    index = (sorted_values.size * p).ceil - 1
+    sorted_values[index].round(2)
+  end
+end
+
+# Usage
+analyzer = LogAnalyzer.new("logs/mcp-server.json")
+
+# Analyze last hour performance
+last_hour = (Time.now - 3600)..Time.now
+stats = analyzer.analyze_performance(last_hour)
+puts "Performance stats: #{stats}"
+
+# Find recent errors
+errors = analyzer.find_errors(last_hour)
+errors.each do |error|
+  puts "Error at #{error[:timestamp]}: #{error[:error]}"
+end
+
+# Trace specific request
+request_trace = analyzer.trace_request("req-123")
+request_trace.each do |entry|
+  puts "#{entry[:timestamp]} [#{entry[:level]}] #{entry[:message]}"
+end
+```
+
+## Testing with Logging
+
+```ruby
+require 'minitest/autorun'
+require 'stringio'
+
+class LoggingTest < Minitest::Test
+  def setup
+    @log_output = StringIO.new
+    @logger = Logger.new(@log_output)
+    
+    @server = Tsikol::Server.new(name: "test")
+    @server.logging true
+    @server.use StructuredLoggingMiddleware, logger: @logger
+    
+    @server.tool "test_tool" do |input:|
+      @server.log :info, "Processing input", size: input.size
+      input.upcase
+    end
+    
+    @client = Tsikol::TestHelpers::TestClient.new(@server)
+  end
+  
+  def test_logs_requests
+    @client.call_tool("test_tool", { "input" => "hello" })
+    
+    logs = parse_log_output
+    
+    assert logs.any? { |log| log[:event] == "request_started" }
+    assert logs.any? { |log| log[:event] == "request_completed" }
+    assert logs.any? { |log| log[:message] == "Processing input" }
+  end
+  
+  def test_logs_errors
+    @server.tool "error_tool" do
+      raise "Test error"
+    end
+    
+    assert_raises(StandardError) do
+      @client.call_tool("error_tool", {})
+    end
+    
+    logs = parse_log_output
+    
+    error_log = logs.find { |log| log[:event] == "request_failed" }
+    assert error_log
+    assert_equal "Test error", error_log[:error][:error_message]
+  end
+  
+  def test_sanitizes_sensitive_data
+    @client.call_tool("test_tool", {
+      "input" => "data",
+      "password" => "secret123"
+    })
+    
+    logs = parse_log_output
+    log_output = @log_output.string
+    
+    refute log_output.include?("secret123")
+    assert log_output.include?("[REDACTED]")
+  end
+  
+  private
+  
+  def parse_log_output
+    @log_output.string.lines.map do |line|
+      JSON.parse(line, symbolize_names: true)
+    rescue JSON::ParserError
+      nil
+    end.compact
+  end
+end
+```
+
+## Best Practices
+
+1. **Use structured logging** (JSON) for easier parsing
+2. **Include request context** in all log entries
+3. **Sanitize sensitive data** before logging
+4. **Use appropriate log levels** (debug, info, warn, error)
+5. **Implement log rotation** to manage disk space
+6. **Centralize logs** for multi-server deployments
+7. **Set up alerts** for critical errors
+8. **Retain audit logs** according to compliance requirements
+9. **Monitor log volume** to detect anomalies
+10. **Use correlation IDs** to trace requests across services
+
+## Next Steps
+
+- Set up [Monitoring](monitoring.md) based on logs
+- Implement [Error Handling](error-handling.md) with proper logging
+- Add [Performance](performance.md) tracking
+- Configure [Security](security.md) audit logging