miniapm 1.0.0

data/lib/miniapm/error_event.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "digest"
+require "time"
+
+module MiniAPM
+  class ErrorEvent
+    attr_reader :exception_class, :message, :backtrace, :fingerprint
+    attr_reader :request_id, :user_id, :params, :timestamp
+    attr_reader :context
+
+    def initialize(
+      exception_class:,
+      message:,
+      backtrace:,
+      fingerprint: nil,
+      request_id: nil,
+      user_id: nil,
+      params: nil,
+      timestamp: nil,
+      context: {}
+    )
+      @exception_class = exception_class
+      @message = truncate(message, 10_000)
+      @backtrace = backtrace&.first(50) || []
+      @fingerprint = fingerprint || generate_fingerprint
+      @request_id = request_id
+      @user_id = user_id&.to_s
+      @params = filter_params(params)
+      @timestamp = timestamp || Time.now.utc
+      @context = context
+    end
+
+    def self.from_exception(exception, context = {})
+      new(
+        exception_class: exception.class.name,
+        message: exception.message,
+        backtrace: exception.backtrace,
+        request_id: context[:request_id] || MiniAPM.current_trace_id,
+        user_id: context[:user_id],
+        params: context[:params],
+        context: context.except(:request_id, :user_id, :params)
+      )
+    end
+
+    def to_h
+      {
+        exception_class: @exception_class,
+        message: @message,
+        backtrace: @backtrace,
+        fingerprint: @fingerprint,
+        request_id: @request_id,
+        user_id: @user_id,
+        params: @params,
+        timestamp: @timestamp.iso8601
+      }.compact
+    end
+
+    private
+
+    def generate_fingerprint
+      # Create a stable fingerprint from exception class, message pattern, and first app backtrace line
+      parts = [@exception_class]
+
+      # Normalize message (remove variable parts like IDs, timestamps)
+      # Order matters: replace UUIDs first before numbers break the pattern
+      normalized_message = @message.to_s
+        .gsub(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, "UUID")  # Replace UUIDs first
+        .gsub(/\b\d+\b/, "N")                    # Replace numbers
+        .gsub(/'[^']*'/, "'X'")                  # Replace quoted strings
+        .gsub(/"[^"]*"/, '"X"')                  # Replace double-quoted strings
+        .slice(0, 200)
+
+      parts << normalized_message
+
+      # Find first application backtrace line (not gem/stdlib)
+      app_line = @backtrace.find do |line|
+        !line.include?("/gems/") &&
+        !line.include?("/ruby/") &&
+        !line.include?("/vendor/") &&
+        !line.start_with?("<")
+      end
+      parts << app_line if app_line
+
+      Digest::SHA256.hexdigest(parts.join("\n"))[0, 32]
+    end
+
+    MAX_FILTER_DEPTH = 10
+
+    def filter_params(params)
+      return nil unless params.is_a?(Hash)
+
+      filter_keys = MiniAPM.configuration.filter_parameters
+
+      deep_filter(params, filter_keys, 0)
+    end
+
+    def deep_filter(hash, filter_keys, depth)
+      return { "__truncated__" => "max depth exceeded" } if depth >= MAX_FILTER_DEPTH
+
+      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, depth + 1)
+        elsif value.is_a?(Array)
+          result[key] = value.first(100).map { |v| v.is_a?(Hash) ? deep_filter(v, filter_keys, depth + 1) : v }
+        else
+          result[key] = 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(string, max_length)
+      return nil if string.nil?
+
+      string = string.to_s
+      string.length > max_length ? string[0, max_length] + "..." : string
+    end
+  end
+end

data/lib/miniapm/exporters/errors.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Exporters
+    class Errors
+      class << self
+        # Export a single error (convenience method, uses batch endpoint)
+        def export(error_event)
+          config = MiniAPM.configuration
+          return { success: false, error: "No API key" } unless config.api_key
+
+          payload = error_event.to_h
+
+          result = Transport::HTTP.post(
+            "#{config.endpoint}/ingest/errors",
+            payload,
+            headers: auth_headers(config)
+          )
+
+          if result[:success]
+            MiniAPM.logger.debug { "MiniAPM: Reported error" }
+          else
+            MiniAPM.logger.debug { "MiniAPM: Failed to report error: #{result[:status]}" }
+          end
+
+          result
+        end
+
+        # Export multiple errors in a single batch request
+        def export_batch(error_events)
+          return { success: true } if error_events.empty?
+
+          config = MiniAPM.configuration
+          return { success: false, error: "No API key" } unless config.api_key
+
+          # Send as a batch array
+          payload = { errors: error_events.map(&:to_h) }
+
+          result = Transport::HTTP.post(
+            "#{config.endpoint}/ingest/errors/batch",
+            payload,
+            headers: auth_headers(config)
+          )
+
+          if result[:success]
+            MiniAPM.logger.debug { "MiniAPM: Reported #{error_events.size} error(s)" }
+          else
+            MiniAPM.logger.warn { "MiniAPM: Failed to report errors: #{result[:status]}" }
+          end
+
+          {
+            success: result[:success],
+            sent: result[:success] ? error_events.size : 0,
+            failed: result[:success] ? 0 : error_events.size,
+            status: result[:status]
+          }
+        end
+
+        private
+
+        def auth_headers(config)
+          { "Authorization" => "Bearer #{config.api_key}" }
+        end
+      end
+    end
+  end
+end

data/lib/miniapm/exporters/otlp.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Exporters
+    class OTLP
+      class << self
+        def export(spans)
+          return if spans.empty?
+
+          config = MiniAPM.configuration
+          return unless config.api_key
+
+          payload = build_otlp_payload(spans, config)
+
+          result = Transport::HTTP.post(
+            "#{config.endpoint}/ingest/v1/traces",
+            payload,
+            headers: auth_headers(config)
+          )
+
+          if result[:success]
+            MiniAPM.logger.debug { "MiniAPM: Exported #{spans.size} spans" }
+          else
+            MiniAPM.logger.debug { "MiniAPM: Failed to export spans: #{result[:status]}" }
+          end
+
+          result
+        end
+
+        private
+
+        def build_otlp_payload(spans, config)
+          {
+            "resourceSpans" => [
+              {
+                "resource" => {
+                  "attributes" => resource_attributes(config)
+                },
+                "scopeSpans" => [
+                  {
+                    "scope" => {
+                      "name" => "miniapm-ruby",
+                      "version" => MiniAPM::VERSION
+                    },
+                    "spans" => spans.map(&:to_otlp)
+                  }
+                ]
+              }
+            ]
+          }
+        end
+
+        def resource_attributes(config)
+          attrs = [
+            kv("service.name", config.service_name),
+            kv("deployment.environment", config.environment)
+          ]
+
+          attrs << kv("service.version", config.service_version) if config.service_version
+          attrs << kv("host.name", config.host) if config.host
+          attrs << kv("telemetry.sdk.name", "miniapm-ruby")
+          attrs << kv("telemetry.sdk.version", MiniAPM::VERSION)
+          attrs << kv("telemetry.sdk.language", "ruby")
+
+          if config.rails_version
+            attrs << kv("rails.version", config.rails_version)
+          end
+
+          if config.ruby_version
+            attrs << kv("ruby.version", config.ruby_version)
+          end
+
+          if config.git_sha
+            attrs << kv("git.sha", config.git_sha)
+          end
+
+          attrs
+        end
+
+        def kv(key, value)
+          { "key" => key, "value" => { "stringValue" => value.to_s } }
+        end
+
+        def auth_headers(config)
+          { "Authorization" => "Bearer #{config.api_key}" }
+        end
+      end
+    end
+  end
+end

data/lib/miniapm/instrumentations/activejob.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class ActiveJob < Base
+      # Keys for trace context in job metadata
+      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?
+          mark_installed!
+
+          # Install the job extension for trace propagation
+          install_job_extension!
+
+          # Subscribe to notifications for metrics/events
+          subscribe("perform.active_job") do |event|
+            handle_perform(event)
+          end
+
+          subscribe("enqueue.active_job") do |event|
+            handle_enqueue(event)
+          end
+
+          subscribe("enqueue_at.active_job") do |event|
+            handle_enqueue(event)
+          end
+
+          subscribe("discard.active_job") do |event|
+            handle_discard(event)
+          end
+
+          subscribe("retry_stopped.active_job") do |event|
+            handle_retry_stopped(event)
+          end
+        end
+
+        private
+
+        def install_job_extension!
+          return unless defined?(::ActiveJob::Base)
+
+          ::ActiveJob::Base.include(JobExtension)
+        end
+
+        def handle_perform(event)
+          # Performance tracking is handled by JobExtension#perform
+          # This is just for additional metadata
+        end
+
+        def handle_enqueue(event)
+          return unless MiniAPM.enabled?
+          return unless Context.current_trace
+
+          job = event.payload[:job]
+
+          span = create_span_from_event(
+            event,
+            name: "#{job.class.name}.enqueue",
+            category: :job,
+            attributes: {
+              "messaging.system" => queue_adapter_name(job),
+              "messaging.destination.name" => job.queue_name,
+              "messaging.operation" => "send",
+              "job.id" => job.job_id,
+              "job.class" => job.class.name
+            }
+          )
+
+          record_span(span)
+        end
+
+        def handle_discard(event)
+          return unless MiniAPM.enabled?
+
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          if error
+            MiniAPM.record_error(error, context: {
+              job_class: job.class.name,
+              job_id: job.job_id,
+              queue: job.queue_name,
+              discarded: true
+            })
+          end
+        end
+
+        def handle_retry_stopped(event)
+          return unless MiniAPM.enabled?
+
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          if error
+            MiniAPM.record_error(error, context: {
+              job_class: job.class.name,
+              job_id: job.job_id,
+              queue: job.queue_name,
+              retry_stopped: true,
+              executions: job.executions
+            })
+          end
+        end
+
+        def queue_adapter_name(job)
+          adapter = job.class.queue_adapter
+          adapter_class = adapter.is_a?(Class) ? adapter : adapter.class
+
+          case adapter_class.name
+          when /SolidQueue/
+            "solid_queue"
+          when /Sidekiq/
+            "sidekiq"
+          when /Async/
+            "async"
+          when /Inline/
+            "inline"
+          when /Delayed/
+            "delayed_job"
+          when /Resque/
+            "resque"
+          when /Sneakers/
+            "sneakers"
+          when /Sucker/
+            "sucker_punch"
+          when /Test/
+            "test"
+          else
+            adapter_class.name.to_s.split("::").last.to_s.gsub(/Adapter$/, "").downcase
+          end
+        rescue StandardError
+          "unknown"
+        end
+      end
+
+      # Extension module included in ActiveJob::Base
+      module JobExtension
+        extend ActiveSupport::Concern
+
+        included do
+          # Serialize trace context before enqueueing
+          before_enqueue do |job|
+            if MiniAPM::Context.current_trace
+              job.miniapm_trace_id = MiniAPM::Context.current_trace_id
+              job.miniapm_parent_span_id = MiniAPM::Context.current_span&.span_id
+              job.miniapm_sampled = MiniAPM::Context.current_trace.sampled?
+            end
+          end
+
+          # Wrap perform with tracing
+          around_perform do |job, block|
+            if MiniAPM.enabled?
+              job.perform_with_tracing(&block)
+            else
+              block.call
+            end
+          end
+        end
+
+        # Accessors for trace context stored in job metadata
+        def miniapm_trace_id
+          @miniapm_trace_id
+        end
+
+        def miniapm_trace_id=(value)
+          @miniapm_trace_id = value
+        end
+
+        def miniapm_parent_span_id
+          @miniapm_parent_span_id
+        end
+
+        def miniapm_parent_span_id=(value)
+          @miniapm_parent_span_id = value
+        end
+
+        def miniapm_sampled
+          @miniapm_sampled
+        end
+
+        def miniapm_sampled=(value)
+          @miniapm_sampled = value
+        end
+
+        # Override serialize to include trace context
+        def serialize
+          super.merge(
+            TRACE_ID_KEY => miniapm_trace_id,
+            PARENT_SPAN_ID_KEY => miniapm_parent_span_id,
+            SAMPLED_KEY => miniapm_sampled
+          ).compact
+        end
+
+        # Override deserialize to restore trace context
+        def deserialize(job_data)
+          super
+          self.miniapm_trace_id = job_data[TRACE_ID_KEY]
+          self.miniapm_parent_span_id = job_data[PARENT_SPAN_ID_KEY]
+          self.miniapm_sampled = job_data[SAMPLED_KEY]
+        end
+
+        def perform_with_tracing
+          # Create trace with propagated context or new trace
+          trace = MiniAPM::Trace.new(
+            trace_id: miniapm_trace_id,
+            sampled: miniapm_sampled
+          )
+
+          # Skip tracing if not sampled
+          return yield unless trace.sampled?
+
+          MiniAPM::Context.current_trace = trace
+
+          span = MiniAPM::Span.new(
+            name: "#{self.class.name}.perform",
+            category: :job,
+            trace_id: trace.trace_id,
+            parent_span_id: miniapm_parent_span_id,
+            attributes: build_job_attributes
+          )
+
+          MiniAPM::Context.with_span(span) do
+            begin
+              yield
+              span.set_ok
+            rescue StandardError => e
+              span.record_exception(e)
+              MiniAPM.record_error(e, context: {
+                job_class: self.class.name,
+                job_id: job_id,
+                queue: queue_name
+              })
+              raise
+            ensure
+              span.finish
+              MiniAPM.record_span(span)
+            end
+          end
+        ensure
+          MiniAPM::Context.clear!
+        end
+
+        private
+
+        def build_job_attributes
+          attrs = {
+            "messaging.system" => MiniAPM::Instrumentations::ActiveJob.send(:queue_adapter_name, self),
+            "messaging.destination.name" => queue_name,
+            "messaging.operation" => "process",
+            "job.id" => job_id,
+            "job.class" => self.class.name,
+            "job.queue" => queue_name,
+            "job.executions" => executions
+          }
+
+          attrs["job.priority"] = priority if priority
+          attrs["job.scheduled_at"] = scheduled_at.iso8601 if scheduled_at
+
+          attrs
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::ActiveJob.install!

data/lib/miniapm/instrumentations/activerecord.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class ActiveRecord < Base
+      IGNORED_QUERIES = ["SCHEMA", "CACHE"].freeze
+      IGNORED_SQL_PATTERNS = /\A\s*(PRAGMA|EXPLAIN|BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)/i
+
+      class << self
+        def install!
+          return if installed?
+          mark_installed!
+
+          subscribe("sql.active_record") do |event|
+            handle_sql(event)
+          end
+        end
+
+        private
+
+        def handle_sql(event)
+          return unless MiniAPM.enabled?
+          return unless Context.current_trace
+
+          payload = event.payload
+
+          # Skip schema queries and internal AR queries
+          return if IGNORED_QUERIES.include?(payload[:name])
+          return if payload[:sql]&.match?(IGNORED_SQL_PATTERNS)
+          return if payload[:cached]
+
+          sql = payload[:sql].to_s
+          operation = extract_operation(sql)
+          table = extract_table(sql)
+
+          name = [operation, table].compact.join(" ")
+          name = operation if name.empty?
+
+          attributes = {
+            "db.system" => adapter_name(payload),
+            "db.operation" => operation
+          }
+
+          attributes["db.sql.table"] = table if table
+
+          # Optionally log SQL (configurable, defaults to off)
+          if MiniAPM.configuration.instrumentations.options(:activerecord)[:log_sql]
+            attributes["db.statement"] = truncate_sql(sql)
+          end
+
+          # Add database name if available
+          db_name = database_name(payload)
+          attributes["db.name"] = db_name if db_name
+
+          # Add connection info
+          if payload[:connection_id]
+            attributes["db.connection_id"] = payload[:connection_id]
+          end
+
+          span = create_span_from_event(
+            event,
+            name: name,
+            category: :db,
+            attributes: attributes
+          )
+
+          record_span(span)
+        end
+
+        def extract_operation(sql)
+          sql.strip.split(/\s+/).first&.upcase || "QUERY"
+        end
+
+        def extract_table(sql)
+          # Match FROM/INTO/UPDATE/JOIN/DELETE FROM table patterns
+          patterns = [
+            /\bFROM\s+[`"']?(\w+)[`"']?/i,
+            /\bINTO\s+[`"']?(\w+)[`"']?/i,
+            /\bUPDATE\s+[`"']?(\w+)[`"']?/i,
+            /\bJOIN\s+[`"']?(\w+)[`"']?/i,
+            /\bDELETE\s+FROM\s+[`"']?(\w+)[`"']?/i
+          ]
+
+          patterns.each do |pattern|
+            match = sql.match(pattern)
+            return match[1] if match
+          end
+
+          nil
+        end
+
+        def adapter_name(payload)
+          if payload[:connection]
+            payload[:connection].adapter_name&.downcase
+          elsif payload[:connection_id] && defined?(::ActiveRecord::Base)
+            ::ActiveRecord::Base.connection.adapter_name.downcase rescue "unknown"
+          else
+            "unknown"
+          end
+        rescue StandardError
+          "unknown"
+        end
+
+        def database_name(payload)
+          if payload[:connection]
+            payload[:connection].current_database rescue nil
+          elsif defined?(::ActiveRecord::Base)
+            ::ActiveRecord::Base.connection.current_database rescue nil
+          end
+        rescue StandardError
+          nil
+        end
+
+        def truncate_sql(sql, max_length: 2000)
+          sql.length > max_length ? sql[0...max_length] + "..." : sql
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::ActiveRecord.install!