miniapm 1.0.0

data/lib/miniapm/instrumentations/sidekiq.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class Sidekiq
+      # Keys used to store trace context in job payload
+      TRACE_ID_KEY = "_miniapm_trace_id"
+      PARENT_SPAN_ID_KEY = "_miniapm_parent_span_id"
+      SAMPLED_KEY = "_miniapm_sampled"
+
+      class << self
+        def install!
+          return if @installed
+          return unless defined?(::Sidekiq)
+
+          @installed = true
+
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add ServerMiddleware
+            end
+          end
+
+          # Also configure client for enqueue tracking and trace propagation
+          ::Sidekiq.configure_client do |config|
+            config.client_middleware do |chain|
+              chain.add ClientMiddleware
+            end
+          end
+
+          # For Sidekiq server process, also add client middleware
+          # (for jobs that enqueue other jobs)
+          ::Sidekiq.configure_server do |config|
+            config.client_middleware do |chain|
+              chain.add ClientMiddleware
+            end
+          end
+
+          MiniAPM.logger.debug { "MiniAPM: Sidekiq instrumentation installed" }
+        end
+
+        def installed?
+          @installed || false
+        end
+      end
+
+      class ServerMiddleware
+        def call(worker, job, queue)
+          return yield unless MiniAPM.enabled?
+
+          # Extract trace context from job if present (propagated from enqueue)
+          trace_id = job[TRACE_ID_KEY]
+          parent_span_id = job[PARENT_SPAN_ID_KEY]
+          sampled = job.key?(SAMPLED_KEY) ? job[SAMPLED_KEY] : nil
+
+          # Create trace with propagated context or new trace
+          trace = Trace.new(
+            trace_id: trace_id,
+            sampled: sampled
+          )
+
+          # Skip if not sampled
+          return yield unless trace.sampled?
+
+          Context.current_trace = trace
+
+          worker_class = worker.class.name
+          job_id = job["jid"]
+
+          span = Span.new(
+            name: "#{worker_class}.perform",
+            category: :job,
+            trace_id: trace.trace_id,
+            parent_span_id: parent_span_id, # Link to parent if propagated
+            attributes: build_attributes(worker_class, job, queue)
+          )
+
+          # Add enqueued_at if present
+          if job["enqueued_at"]
+            span.add_attribute("sidekiq.enqueued_at", job["enqueued_at"])
+            # Calculate queue latency
+            latency = Time.now.to_f - job["enqueued_at"]
+            span.add_attribute("sidekiq.queue_latency_ms", (latency * 1000).round(2))
+          end
+
+          # Add wrapped class for ActiveJob
+          if job["wrapped"]
+            span.add_attribute("sidekiq.wrapped", job["wrapped"])
+            span.add_attribute("job.class", job["wrapped"])
+          end
+
+          Context.with_span(span) do
+            begin
+              yield
+              span.set_ok
+            rescue StandardError => e
+              span.record_exception(e)
+              MiniAPM.record_error(e, context: {
+                job_class: worker_class,
+                job_id: job_id,
+                queue: queue
+              })
+              raise
+            ensure
+              span.finish
+              MiniAPM.record_span(span)
+            end
+          end
+        ensure
+          Context.clear!
+        end
+
+        private
+
+        def build_attributes(worker_class, job, queue)
+          {
+            "messaging.system" => "sidekiq",
+            "messaging.destination.name" => queue,
+            "messaging.operation" => "process",
+            "sidekiq.job_id" => job["jid"],
+            "sidekiq.queue" => queue,
+            "sidekiq.retry_count" => job["retry_count"] || 0,
+            "sidekiq.created_at" => job["created_at"],
+            "job.class" => worker_class
+          }
+        end
+      end
+
+      class ClientMiddleware
+        def call(worker_class, job, queue, redis_pool)
+          # Always propagate trace context if available
+          inject_trace_context(job)
+
+          return yield unless MiniAPM.enabled?
+          return yield unless Context.current_trace
+
+          # Create span for enqueue operation
+          worker_name = worker_class.is_a?(Class) ? worker_class.name : worker_class.to_s
+
+          span = Span.new(
+            name: "#{worker_name}.enqueue",
+            category: :job,
+            trace_id: Context.current_trace_id,
+            parent_span_id: Context.current_span&.span_id,
+            attributes: {
+              "messaging.system" => "sidekiq",
+              "messaging.destination.name" => queue,
+              "messaging.operation" => "send",
+              "sidekiq.job_id" => job["jid"],
+              "job.class" => worker_name
+            }
+          )
+
+          Context.with_span(span) do
+            begin
+              result = yield
+              span.set_ok
+              result
+            rescue StandardError => e
+              span.record_exception(e)
+              raise
+            ensure
+              span.finish
+              MiniAPM.record_span(span)
+            end
+          end
+        end
+
+        private
+
+        def inject_trace_context(job)
+          return unless Context.current_trace
+
+          # Store trace context in job payload for propagation
+          job[TRACE_ID_KEY] = Context.current_trace_id
+          job[PARENT_SPAN_ID_KEY] = Context.current_span&.span_id
+          job[SAMPLED_KEY] = Context.current_trace.sampled?
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Sidekiq.install!

data/lib/miniapm/middleware/error_handler.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Middleware
+    class ErrorHandler
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue StandardError => e
+        report_error(e, env)
+        raise
+      end
+
+      private
+
+      def report_error(exception, env)
+        return unless MiniAPM.enabled?
+        return if ignored_exception?(exception)
+
+        MiniAPM.record_error(exception, context: build_context(env))
+      end
+
+      def ignored_exception?(exception)
+        MiniAPM.configuration.ignored_exceptions.include?(exception.class.name)
+      end
+
+      def build_context(env)
+        request = ::Rack::Request.new(env) if defined?(::Rack::Request)
+
+        context = {
+          request_id: env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
+          user_id: extract_user_id(env),
+          url: build_url(env),
+          method: env["REQUEST_METHOD"]
+        }
+
+        # Add filtered params
+        if request
+          context[:params] = filter_params(request.params)
+        end
+
+        context.compact
+      end
+
+      def extract_user_id(env)
+        # Try common patterns for user identification
+        # Warden (Devise)
+        if env["warden"]
+          user = env["warden"].user rescue nil
+          return user.id.to_s if user&.respond_to?(:id)
+        end
+
+        # Session-based
+        if env["rack.session"]
+          session = env["rack.session"]
+          return session["user_id"].to_s if session["user_id"]
+          return session["current_user_id"].to_s if session["current_user_id"]
+
+          # Devise session format
+          warden_key = session["warden.user.user.key"]
+          if warden_key.is_a?(Array) && warden_key.first.is_a?(Array)
+            return warden_key.first.first.to_s
+          end
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def filter_params(params)
+        return nil unless params.is_a?(Hash)
+        return nil if params.empty?
+
+        filter_keys = MiniAPM.configuration.filter_parameters
+
+        deep_filter(params, filter_keys)
+      end
+
+      def deep_filter(hash, filter_keys)
+        hash.each_with_object({}) do |(key, value), result|
+          if filter_keys.any? { |f| key_matches?(key, f) }
+            result[key] = "[FILTERED]"
+          elsif value.is_a?(Hash)
+            result[key] = deep_filter(value, filter_keys)
+          elsif value.is_a?(Array)
+            result[key] = value.map { |v| v.is_a?(Hash) ? deep_filter(v, filter_keys) : v }
+          else
+            # Truncate long values
+            result[key] = truncate_value(value)
+          end
+        end
+      end
+
+      def key_matches?(key, filter)
+        case filter
+        when Regexp
+          key.to_s.match?(filter)
+        else
+          key.to_s.downcase.include?(filter.to_s.downcase)
+        end
+      end
+
+      def truncate_value(value)
+        str = value.to_s
+        str.length > 500 ? str[0, 500] + "..." : str
+      end
+
+      def build_url(env)
+        scheme = env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"] || "#{env['SERVER_NAME']}:#{env['SERVER_PORT']}"
+        path = env["PATH_INFO"]
+        "#{scheme}://#{host}#{path}"
+      end
+    end
+  end
+end

data/lib/miniapm/middleware/rack.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Middleware
+    class Rack
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless MiniAPM.enabled?
+
+        # Extract incoming trace context from headers
+        incoming = Context.extract_from_headers(env)
+
+        # Create trace (with incoming context if present)
+        trace = Trace.new(
+          trace_id: incoming&.dig(:trace_id),
+          sampled: incoming&.dig(:sampled)
+        )
+
+        return @app.call(env) unless trace.sampled?
+
+        Context.with_trace(trace) do
+          request = ::Rack::Request.new(env) if defined?(::Rack::Request)
+          request_method = env["REQUEST_METHOD"]
+          request_path = env["PATH_INFO"]
+          request_url = build_url(env)
+
+          span = Span.new(
+            name: "#{request_method} #{request_path}",
+            category: :http_server,
+            trace_id: trace.trace_id,
+            attributes: build_attributes(env, request)
+          )
+
+          Context.with_span(span) do
+            begin
+              status, headers, body = @app.call(env)
+
+              span.add_attribute("http.status_code", status)
+              span.set_error("HTTP #{status}") if status >= 500
+
+              [status, headers, body]
+            rescue StandardError => e
+              span.record_exception(e)
+              raise
+            ensure
+              span.finish
+              MiniAPM.record_span(span)
+            end
+          end
+        end
+      end
+
+      private
+
+      def build_attributes(env, request)
+        attrs = {
+          "http.method" => env["REQUEST_METHOD"],
+          "http.url" => build_url(env),
+          "http.scheme" => env["rack.url_scheme"] || "http",
+          "http.host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+          "http.target" => env["PATH_INFO"]
+        }
+
+        # Add query string if present (without values for privacy)
+        if env["QUERY_STRING"] && !env["QUERY_STRING"].empty?
+          attrs["http.query_params"] = env["QUERY_STRING"].split("&").map { |p| p.split("=").first }.join(",")
+        end
+
+        # Add user agent if present
+        if env["HTTP_USER_AGENT"]
+          attrs["http.user_agent"] = env["HTTP_USER_AGENT"]
+        end
+
+        # Add request ID if present (Rails sets this)
+        request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
+        if request_id
+          attrs["http.request_id"] = request_id
+        end
+
+        # Add client IP
+        client_ip = env["HTTP_X_FORWARDED_FOR"]&.split(",")&.first&.strip ||
+                    env["HTTP_X_REAL_IP"] ||
+                    env["REMOTE_ADDR"]
+        if client_ip
+          attrs["http.client_ip"] = client_ip
+        end
+
+        attrs
+      end
+
+      def build_url(env)
+        scheme = env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"] || "#{env['SERVER_NAME']}:#{env['SERVER_PORT']}"
+        path = env["PATH_INFO"]
+        # Omit query string from URL for privacy
+        "#{scheme}://#{host}#{path}"
+      end
+    end
+  end
+end

data/lib/miniapm/span.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module MiniAPM
+  class Span
+    # OTLP SpanKind values
+    KINDS = {
+      unspecified: 0,
+      internal: 1,
+      server: 2,
+      client: 3,
+      producer: 4,
+      consumer: 5
+    }.freeze
+
+    # MiniAPM categories mapped to OTLP kinds
+    CATEGORY_KINDS = {
+      http_server: :server,
+      http_client: :client,
+      db: :client,
+      view: :internal,
+      search: :client,
+      job: :consumer,
+      rake: :internal,
+      cache: :internal,
+      internal: :internal
+    }.freeze
+
+    # Status codes
+    STATUS_UNSET = 0
+    STATUS_OK = 1
+    STATUS_ERROR = 2
+
+    # Limits to prevent memory issues
+    MAX_NAME_LENGTH = 256
+    MAX_ATTRIBUTE_KEY_LENGTH = 128
+    MAX_ATTRIBUTE_VALUE_LENGTH = 4096
+    MAX_ATTRIBUTES = 128
+    MAX_EVENTS = 128
+    MAX_EVENT_ATTRIBUTES = 32
+    TRACE_ID_LENGTH = 32
+    SPAN_ID_LENGTH = 16
+
+    attr_reader :trace_id, :span_id, :parent_span_id
+    attr_reader :name, :category, :kind
+    attr_reader :start_time, :end_time
+    attr_reader :attributes, :events
+    attr_accessor :status_code, :status_message
+
+    def initialize(
+      name:,
+      category: :internal,
+      trace_id: nil,
+      parent_span_id: nil,
+      attributes: {}
+    )
+      @name = validate_name(name)
+      @category = validate_category(category)
+      @kind = KINDS[CATEGORY_KINDS[@category] || :internal]
+
+      @trace_id = validate_trace_id(trace_id) || generate_trace_id
+      @span_id = generate_span_id
+      @parent_span_id = validate_span_id(parent_span_id)
+
+      @start_time = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+      @end_time = nil
+
+      @attributes = {}
+      @events = []
+
+      @status_code = STATUS_UNSET
+      @status_message = nil
+
+      # Add initial attributes with validation
+      attributes.each { |k, v| add_attribute(k, v) }
+    end
+
+    def self.new_root(name, category: :http_server, attributes: {})
+      trace = Trace.new
+      Context.current_trace = trace
+
+      new(
+        name: name,
+        category: category,
+        trace_id: trace.trace_id,
+        attributes: attributes
+      )
+    end
+
+    def create_child(name, category: :internal, attributes: {})
+      self.class.new(
+        name: name,
+        category: category,
+        trace_id: @trace_id,
+        parent_span_id: @span_id,
+        attributes: attributes
+      )
+    end
+
+    def finish
+      @end_time = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+    end
+
+    def duration_ns
+      (@end_time || Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)) - @start_time
+    end
+
+    def duration_ms
+      duration_ns / 1_000_000.0
+    end
+
+    def add_attribute(key, value)
+      return if @attributes.size >= MAX_ATTRIBUTES
+
+      key = truncate(key.to_s, MAX_ATTRIBUTE_KEY_LENGTH)
+      value = sanitize_attribute_value(value)
+
+      @attributes[key] = value
+    end
+
+    def add_event(name, attributes: {})
+      return if @events.size >= MAX_EVENTS
+
+      event_attrs = {}
+      attributes.first(MAX_EVENT_ATTRIBUTES).each do |k, v|
+        key = truncate(k.to_s, MAX_ATTRIBUTE_KEY_LENGTH)
+        event_attrs[key] = sanitize_attribute_value(v)
+      end
+
+      @events << {
+        name: truncate(name, MAX_NAME_LENGTH),
+        time_unix_nano: Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond),
+        attributes: event_attrs
+      }
+    end
+
+    def record_exception(exception)
+      @status_code = STATUS_ERROR
+      @status_message = truncate(exception.message, MAX_ATTRIBUTE_VALUE_LENGTH)
+
+      add_event("exception", attributes: {
+        "exception.type" => exception.class.name,
+        "exception.message" => exception.message,
+        "exception.stacktrace" => exception.backtrace&.first(30)&.join("\n")
+      })
+    end
+
+    def set_error(message = nil)
+      @status_code = STATUS_ERROR
+      @status_message = message ? truncate(message, MAX_ATTRIBUTE_VALUE_LENGTH) : nil
+    end
+
+    def set_ok
+      @status_code = STATUS_OK
+    end
+
+    def root?
+      @parent_span_id.nil?
+    end
+
+    def error?
+      @status_code == STATUS_ERROR
+    end
+
+    # Convert to OTLP JSON format
+    def to_otlp
+      span_data = {
+        "traceId" => @trace_id,
+        "spanId" => @span_id,
+        "name" => @name,
+        "kind" => @kind,
+        "startTimeUnixNano" => @start_time.to_s,
+        "endTimeUnixNano" => (@end_time || @start_time).to_s,
+        "attributes" => attributes_to_otlp,
+        "status" => build_status
+      }
+
+      span_data["parentSpanId"] = @parent_span_id if @parent_span_id
+      span_data["events"] = events_to_otlp if @events.any?
+
+      span_data
+    end
+
+    private
+
+    def validate_name(name)
+      truncate(name.to_s, MAX_NAME_LENGTH)
+    end
+
+    def validate_category(category)
+      cat = category.to_sym
+      CATEGORY_KINDS.key?(cat) ? cat : :internal
+    end
+
+    def validate_trace_id(trace_id)
+      return nil if trace_id.nil?
+
+      str = trace_id.to_s.downcase
+      return nil unless str.match?(/\A[0-9a-f]{32}\z/)
+
+      str
+    end
+
+    def validate_span_id(span_id)
+      return nil if span_id.nil?
+
+      str = span_id.to_s.downcase
+      return nil unless str.match?(/\A[0-9a-f]{16}\z/)
+
+      str
+    end
+
+    def generate_trace_id
+      SecureRandom.hex(16)
+    end
+
+    def generate_span_id
+      SecureRandom.hex(8)
+    end
+
+    def truncate(string, max_length)
+      return "" if string.nil?
+
+      str = string.to_s
+      str.length > max_length ? str[0, max_length] : str
+    end
+
+    def sanitize_attribute_value(value)
+      case value
+      when String
+        truncate(value, MAX_ATTRIBUTE_VALUE_LENGTH)
+      when Integer, Float, TrueClass, FalseClass, NilClass
+        value
+      when Array
+        # Limit array size and sanitize each element
+        value.first(32).map { |v| sanitize_attribute_value(v) }
+      when Hash
+        # Convert hash to string representation
+        truncate(value.to_s, MAX_ATTRIBUTE_VALUE_LENGTH)
+      else
+        truncate(value.to_s, MAX_ATTRIBUTE_VALUE_LENGTH)
+      end
+    end
+
+    def attributes_to_otlp
+      @attributes.map do |key, value|
+        { "key" => key, "value" => value_to_otlp(value) }
+      end
+    end
+
+    def events_to_otlp
+      @events.map do |event|
+        {
+          "name" => event[:name],
+          "timeUnixNano" => event[:time_unix_nano].to_s,
+          "attributes" => event[:attributes].map do |k, v|
+            { "key" => k, "value" => value_to_otlp(v) }
+          end
+        }
+      end
+    end
+
+    def value_to_otlp(value)
+      case value
+      when String
+        { "stringValue" => value }
+      when Integer
+        { "intValue" => value.to_s }
+      when Float
+        { "doubleValue" => value }
+      when TrueClass, FalseClass
+        { "boolValue" => value }
+      when Array
+        { "arrayValue" => { "values" => value.map { |v| value_to_otlp(v) } } }
+      when nil
+        { "stringValue" => "" }
+      else
+        { "stringValue" => value.to_s }
+      end
+    end
+
+    def build_status
+      status = { "code" => @status_code }
+      status["message"] = @status_message if @status_message
+      status
+    end
+  end
+end