miniapm 1.0.0

data/lib/miniapm/instrumentations/redis/redis.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Redis
+      class Redis
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::Redis)
+            # Skip if redis-client is present (it's the modern replacement)
+            return if defined?(::RedisClient)
+
+            @installed = true
+            ::Redis::Client.prepend(Patch)
+
+            MiniAPM.logger.debug { "MiniAPM: redis gem instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Patch
+          def call(command)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            operation = command.first.to_s.upcase
+            conn_info = extract_connection_info
+
+            span = MiniAPM::Span.new(
+              name: "REDIS #{operation}",
+              category: :cache,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "redis",
+                "db.operation" => operation,
+                "db.redis.database_index" => conn_info[:db],
+                "net.peer.name" => conn_info[:host],
+                "net.peer.port" => conn_info[:port]
+              }.compact
+            )
+
+            # Add key info for common operations
+            if command.length > 1 && %w[GET SET DEL INCR DECR EXPIRE TTL EXISTS HGET HSET LPUSH RPUSH].include?(operation)
+              key = command[1].to_s
+              span.add_attribute("db.redis.key", truncate_key(key))
+            end
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                result = super
+                span.set_ok
+                result
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          def call_pipeline(pipeline)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            commands = pipeline.commands
+            operations = commands.map { |c| c.first.to_s.upcase }.uniq.join(", ")
+            conn_info = extract_connection_info
+
+            span = MiniAPM::Span.new(
+              name: "REDIS PIPELINE (#{commands.size} commands)",
+              category: :cache,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "redis",
+                "db.operation" => "PIPELINE",
+                "db.redis.database_index" => conn_info[:db],
+                "db.redis.pipeline_length" => commands.size,
+                "db.redis.operations" => operations,
+                "net.peer.name" => conn_info[:host],
+                "net.peer.port" => conn_info[:port]
+              }.compact
+            )
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                result = super
+                span.set_ok
+                result
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def extract_connection_info
+            # Redis::Client in older redis gem versions has different APIs
+            # Try various methods to get connection info safely
+            {
+              host: safe_connection_value(:host),
+              port: safe_connection_value(:port),
+              db: safe_connection_value(:db)
+            }
+          end
+
+          def safe_connection_value(attr)
+            respond_to?(attr) ? send(attr) : options[attr]
+          rescue
+            nil
+          end
+
+          def truncate_key(key)
+            key.length > 100 ? key[0...100] + "..." : key
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Redis::Redis.install!

data/lib/miniapm/instrumentations/redis/redis_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Redis
+      class RedisClient
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::RedisClient)
+
+            @installed = true
+
+            # RedisClient supports middleware registration
+            ::RedisClient.register(Middleware)
+
+            MiniAPM.logger.debug { "MiniAPM: redis-client instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Middleware
+          def call(command, config)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            operation = command.first.to_s.upcase
+
+            span = MiniAPM::Span.new(
+              name: "REDIS #{operation}",
+              category: :cache,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "redis",
+                "db.operation" => operation,
+                "db.redis.database_index" => config.db,
+                "net.peer.name" => config.host,
+                "net.peer.port" => config.port
+              }
+            )
+
+            # Add key info for common operations (first arg after command)
+            if command.length > 1 && %w[GET SET DEL INCR DECR EXPIRE TTL EXISTS HGET HSET LPUSH RPUSH].include?(operation)
+              key = command[1].to_s
+              span.add_attribute("db.redis.key", truncate_key(key))
+            end
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                result = super
+                span.set_ok
+                result
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          def call_pipelined(commands, config)
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            operations = commands.map { |c| c.first.to_s.upcase }.uniq.join(", ")
+
+            span = MiniAPM::Span.new(
+              name: "REDIS PIPELINE (#{commands.size} commands)",
+              category: :cache,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "redis",
+                "db.operation" => "PIPELINE",
+                "db.redis.database_index" => config.db,
+                "db.redis.pipeline_length" => commands.size,
+                "db.redis.operations" => operations,
+                "net.peer.name" => config.host,
+                "net.peer.port" => config.port
+              }
+            )
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                result = super
+                span.set_ok
+                result
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def truncate_key(key)
+            key.length > 100 ? key[0...100] + "..." : key
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Redis::RedisClient.install!

data/lib/miniapm/instrumentations/registry.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    class Registry
+      INSTRUMENTATIONS = {
+        # Rails core (via ActiveSupport::Notifications)
+        rails: "miniapm/instrumentations/rails/controller",
+        activerecord: "miniapm/instrumentations/activerecord",
+        activejob: "miniapm/instrumentations/activejob",
+        cache: "miniapm/instrumentations/cache",
+
+        # Background jobs
+        sidekiq: "miniapm/instrumentations/sidekiq",
+
+        # HTTP clients
+        net_http: "miniapm/instrumentations/http/net_http",
+        httparty: "miniapm/instrumentations/http/httparty",
+        faraday: "miniapm/instrumentations/http/faraday",
+
+        # Search
+        opensearch: "miniapm/instrumentations/search/opensearch",
+        elasticsearch: "miniapm/instrumentations/search/elasticsearch",
+        searchkick: "miniapm/instrumentations/search/searchkick",
+
+        # Redis
+        redis_client: "miniapm/instrumentations/redis/redis_client",
+        redis: "miniapm/instrumentations/redis/redis"
+      }.freeze
+
+      class << self
+        def install_all!
+          INSTRUMENTATIONS.each do |name, path|
+            next unless should_install?(name)
+
+            begin
+              require_relative path.sub("miniapm/instrumentations/", "")
+              MiniAPM.logger.debug { "MiniAPM: Installed #{name} instrumentation" }
+            rescue LoadError => e
+              MiniAPM.logger.debug { "MiniAPM: Skipped #{name} (dependency not available: #{e.message})" }
+            rescue StandardError => e
+              MiniAPM.logger.warn { "MiniAPM: Failed to install #{name}: #{e.message}" }
+            end
+          end
+        end
+
+        private
+
+        def should_install?(name)
+          MiniAPM.configuration.instrumentations.enabled?(name) && gem_present?(name)
+        end
+
+        def gem_present?(name)
+          result = case name
+          when :rails
+            defined?(Rails) && defined?(ActionController)
+          when :activerecord
+            defined?(ActiveRecord::Base) && defined?(ActiveSupport::Notifications)
+          when :activejob
+            defined?(ActiveJob::Base) && defined?(ActiveSupport::Notifications)
+          when :sidekiq
+            defined?(Sidekiq)
+          when :cache
+            defined?(ActiveSupport::Cache::Store)
+          when :net_http
+            defined?(Net::HTTP)
+          when :httparty
+            defined?(HTTParty)
+          when :faraday
+            defined?(Faraday)
+          when :opensearch
+            defined?(OpenSearch::Client)
+          when :elasticsearch
+            defined?(Elasticsearch::Client)
+          when :searchkick
+            defined?(Searchkick)
+          when :redis_client
+            defined?(RedisClient)
+          when :redis
+            defined?(Redis) && !defined?(RedisClient)
+          else
+            false
+          end
+          # Convert to boolean (defined? returns string or nil)
+          !!result
+        end
+      end
+    end
+  end
+end

data/lib/miniapm/instrumentations/search/elasticsearch.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Search
+      class Elasticsearch
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::Elasticsearch::Transport::Client)
+
+            @installed = true
+            ::Elasticsearch::Transport::Client.prepend(Patch)
+
+            MiniAPM.logger.debug { "MiniAPM: Elasticsearch instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Patch
+          def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            operation = extract_operation(method, path)
+            index = extract_index(path)
+
+            span = MiniAPM::Span.new(
+              name: "ES #{operation}#{index ? " #{index}" : ""}",
+              category: :search,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "elasticsearch",
+                "db.operation" => operation,
+                "http.method" => method.to_s.upcase,
+                "http.url" => path
+              }
+            )
+
+            span.add_attribute("elasticsearch.index", index) if index
+
+            # Add query body for search operations (truncated)
+            if body && %w[search msearch].include?(operation)
+              span.add_attribute("db.statement", truncate_body(body))
+            end
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                response = super
+
+                if response
+                  span.add_attribute("http.status_code", response.status)
+                  span.set_error("ES #{response.status}") if response.status >= 400
+                end
+
+                response
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def extract_operation(method, path)
+            case
+            when path.include?("_search")
+              "search"
+            when path.include?("_msearch")
+              "msearch"
+            when path.include?("_bulk")
+              "bulk"
+            when path.include?("_count")
+              "count"
+            when path.include?("_update")
+              "update"
+            when path.include?("_delete_by_query")
+              "delete_by_query"
+            when path.include?("_refresh")
+              "refresh"
+            when method.to_s.upcase == "GET"
+              "get"
+            when method.to_s.upcase == "PUT"
+              "index"
+            when method.to_s.upcase == "POST"
+              "index"
+            when method.to_s.upcase == "DELETE"
+              "delete"
+            else
+              "query"
+            end
+          end
+
+          def extract_index(path)
+            # Extract index name from path like /my_index/_search
+            parts = path.to_s.split("/").reject { |p| p.empty? || p.start_with?("_") }
+            parts.first
+          end
+
+          def truncate_body(body)
+            json = body.is_a?(String) ? body : body.to_json
+            json.length > 1000 ? json[0...1000] + "..." : json
+          rescue StandardError
+            body.to_s[0...1000]
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Search::Elasticsearch.install!

data/lib/miniapm/instrumentations/search/opensearch.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Search
+      class OpenSearch
+        class << self
+          def install!
+            return if @installed
+            return unless defined?(::OpenSearch::Transport::Client)
+
+            @installed = true
+            ::OpenSearch::Transport::Client.prepend(Patch)
+
+            MiniAPM.logger.debug { "MiniAPM: OpenSearch instrumentation installed" }
+          end
+
+          def installed?
+            @installed || false
+          end
+        end
+
+        module Patch
+          def perform_request(method, path, params = {}, body = nil, headers = nil, opts = {})
+            return super unless MiniAPM.enabled?
+            return super unless MiniAPM::Context.current_trace
+
+            operation = extract_operation(method, path)
+            index = extract_index(path)
+
+            span = MiniAPM::Span.new(
+              name: "OS #{operation}#{index ? " #{index}" : ""}",
+              category: :search,
+              trace_id: MiniAPM::Context.current_trace_id,
+              parent_span_id: MiniAPM::Context.current_span&.span_id,
+              attributes: {
+                "db.system" => "opensearch",
+                "db.operation" => operation,
+                "http.method" => method.to_s.upcase,
+                "http.url" => path
+              }
+            )
+
+            span.add_attribute("opensearch.index", index) if index
+
+            # Add query body for search operations (truncated)
+            if body && %w[search msearch].include?(operation)
+              span.add_attribute("db.statement", truncate_body(body))
+            end
+
+            MiniAPM::Context.with_span(span) do
+              begin
+                response = super
+
+                if response
+                  span.add_attribute("http.status_code", response.status)
+                  span.set_error("OS #{response.status}") if response.status >= 400
+                end
+
+                response
+              rescue StandardError => e
+                span.record_exception(e)
+                raise
+              ensure
+                span.finish
+                MiniAPM.record_span(span)
+              end
+            end
+          end
+
+          private
+
+          def extract_operation(method, path)
+            case
+            when path.include?("_search")
+              "search"
+            when path.include?("_msearch")
+              "msearch"
+            when path.include?("_bulk")
+              "bulk"
+            when path.include?("_count")
+              "count"
+            when path.include?("_update")
+              "update"
+            when path.include?("_delete_by_query")
+              "delete_by_query"
+            when path.include?("_refresh")
+              "refresh"
+            when method.to_s.upcase == "GET"
+              "get"
+            when method.to_s.upcase == "PUT"
+              "index"
+            when method.to_s.upcase == "POST"
+              "index"
+            when method.to_s.upcase == "DELETE"
+              "delete"
+            else
+              "query"
+            end
+          end
+
+          def extract_index(path)
+            parts = path.to_s.split("/").reject { |p| p.empty? || p.start_with?("_") }
+            parts.first
+          end
+
+          def truncate_body(body)
+            json = body.is_a?(String) ? body : body.to_json
+            json.length > 1000 ? json[0...1000] + "..." : json
+          rescue StandardError
+            body.to_s[0...1000]
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Search::OpenSearch.install!

data/lib/miniapm/instrumentations/search/searchkick.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module MiniAPM
+  module Instrumentations
+    module Search
+      class Searchkick < Base
+        class << self
+          def install!
+            return if installed?
+            return unless defined?(::Searchkick)
+
+            mark_installed!
+
+            # Searchkick uses ActiveSupport::Notifications
+            subscribe("search.searchkick") do |event|
+              handle_search(event)
+            end
+
+            subscribe("request.searchkick") do |event|
+              handle_request(event)
+            end
+
+            subscribe("reindex.searchkick") do |event|
+              handle_reindex(event)
+            end
+
+            MiniAPM.logger.debug { "MiniAPM: Searchkick instrumentation installed" }
+          end
+
+          private
+
+          def handle_search(event)
+            return unless MiniAPM.enabled?
+            return unless Context.current_trace
+
+            payload = event.payload
+            model_name = payload[:name] || "unknown"
+
+            attributes = {
+              "db.system" => "elasticsearch",
+              "db.operation" => "search",
+              "searchkick.model" => model_name
+            }
+
+            # Add query info (truncated for privacy)
+            if payload[:query]
+              query_str = payload[:query].to_s
+              attributes["searchkick.query"] = query_str.length > 500 ? query_str[0...500] + "..." : query_str
+            end
+
+            # Add body for debugging
+            if payload[:body]
+              body_str = payload[:body].is_a?(String) ? payload[:body] : payload[:body].to_json
+              attributes["db.statement"] = body_str.length > 1000 ? body_str[0...1000] + "..." : body_str
+            end
+
+            span = create_span_from_event(
+              event,
+              name: "searchkick #{model_name}",
+              category: :search,
+              attributes: attributes
+            )
+
+            record_span(span)
+          end
+
+          def handle_request(event)
+            # Lower-level ES/OS requests from Searchkick
+            return unless MiniAPM.enabled?
+            return unless Context.current_trace
+
+            payload = event.payload
+
+            attributes = {
+              "db.system" => "elasticsearch",
+              "http.method" => payload[:method]&.to_s&.upcase,
+              "http.url" => payload[:path]
+            }
+
+            span = create_span_from_event(
+              event,
+              name: "searchkick #{payload[:method]} #{payload[:path]}",
+              category: :search,
+              attributes: attributes
+            )
+
+            record_span(span)
+          end
+
+          def handle_reindex(event)
+            return unless MiniAPM.enabled?
+            return unless Context.current_trace
+
+            payload = event.payload
+            model_name = payload[:name] || "unknown"
+
+            attributes = {
+              "db.system" => "elasticsearch",
+              "db.operation" => "reindex",
+              "searchkick.model" => model_name
+            }
+
+            span = create_span_from_event(
+              event,
+              name: "searchkick reindex #{model_name}",
+              category: :search,
+              attributes: attributes
+            )
+
+            record_span(span)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Auto-install when loaded
+MiniAPM::Instrumentations::Search::Searchkick.install!