baseline_red_rpm 1.0.0

data/lib/baseline_red_rpm/instruments/redis.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module Redis
+      include BaselineRedRpm::Utils
+
+      def call_with_trace(*command, &block)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("redis", tags: {
+            "component" => "Redis",
+            "span.kind" => "client",
+            "peer.address" => self.host,
+            "peer.port" => self.port,
+            "db.type" => "redis",
+            "db.vendor" => "redis",
+            "db.instance" => self.db,
+            "db.statement" => format_redis_command(*command)
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :redis)
+        end
+
+        call_without_trace(*command, &block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+
+      def call_pipeline_with_trace(*pipeline)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("redis", tags: {
+            "component" => "Redis",
+            "span.kind" => "client",
+            "peer.address" => self.host,
+            "peer.port" => self.port,
+            "db.type" => "redis",
+            "db.vendor" => "redis",
+            "db.instance" => self.db,
+            "db.statement" => pipeline[0].commands.map { |c| format_redis_command(c) }.join("\n")
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :redis)
+        end
+
+        call_pipeline_without_trace(*pipeline)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:redis][:enabled] &&
+  defined?(::Redis)
+  ::BaselineRedRpm.logger.info "Initializing redis tracer."
+
+  ::Redis::Client.send(:include, ::BaselineRedRpm::Instruments::Redis)
+
+  ::Redis::Client.class_eval do
+    alias_method :call_without_trace, :call
+    alias_method :call, :call_with_trace
+    alias_method :call_pipeline_without_trace, :call_pipeline
+    alias_method :call_pipeline, :call_pipeline_with_trace
+  end
+end

data/lib/baseline_red_rpm/instruments/roda.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module Roda
+      def call_with_trace(&block)
+        if BaselineRedRpm::Tracer.tracing?
+          req = ::Rack::Request.new(env)
+          request_method = req.request_method.to_s.upcase
+          path = req.path
+
+          parts = path.to_s.rpartition("/")
+          action = parts.last
+          controller = parts.first.sub(/\A\//, '').split("/").collect {|w| w.capitalize }.join("::")
+          operation = "#{controller}##{action}"
+
+          span = BaselineRedRpm.tracer.start_span(operation, tags: {
+            "component" => "Roda",
+            "http.url" => path,
+            "http.method" => request_method,
+            "params" => @_request.params
+          })
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :roda)
+        end
+
+        call_without_trace(&block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if defined?(::Roda) && ::BaselineRedRpm.config.instrumentation[:roda][:enabled]
+  ::BaselineRedRpm.logger.info "Initializing roda tracer."
+
+  ::Roda::RodaPlugins::Base::InstanceMethods.send(:include, BaselineRedRpm::Instruments::Roda)
+  ::Roda::RodaPlugins::Base::InstanceMethods.class_eval do
+    alias_method :call_without_trace, :call
+    alias_method :call, :call_with_trace
+  end
+end

data/lib/baseline_red_rpm/instruments/sequel.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module Sequel
+      def sanitize_sql(sql)
+        regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
+        sql.to_s.gsub(regexp, '?')
+      end
+
+      def parse_opts(sql, opts)
+        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
+          db_opts = @opts
+        elsif @pool
+          db_opts = @pool.db.opts
+        else
+          db_opts = @db.opts
+        end
+
+        if ::Sequel::VERSION > '4.36.0' && !sql.is_a?(String)
+          # In 4.37.0, sql was converted to a prepared statement object
+          sql = sql.prepared_sql unless sql.is_a?(Symbol)
+        end
+
+        {
+          "db.type" => opts[:type],
+          "db.statement" => sanitize_sql(sql),
+          "db.instance" => db_opts[:database],
+          "db.user" => db_opts[:user],
+          "db.vendor" => db_opts[:adapter],
+          "peer.address" => db_opts[:host],
+          "peer.port" => db_opts[:port]
+        }
+      end
+    end
+
+    module SequelDatabase
+      include ::BaselineRedRpm::Instruments::Sequel
+
+      def run_with_trace(sql, options = ::Sequel::OPTS)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("sequel", tags: parse_opts(sql, options))
+          span.set_tag "component", "Sequel"
+          span.set_tag "span.kind", "client"
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :sequel)
+        end
+
+        run_without_trace(sql, options)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+
+    module SequelDataset
+      include ::BaselineRedRpm::Instruments::Sequel
+
+      def execute_with_trace(sql, options = ::Sequel::OPTS, &block)
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("sequel", tags: parse_opts(sql, options))
+          span.set_tag "component", "Sequel"
+          span.set_tag "span.kind", "client"
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :sequel)
+        end
+
+        execute_without_trace(sql, options, &block)
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:sequel][:enabled] && defined?(::Sequel)
+  ::BaselineRedRpm.logger.info "Initializing sequel tracer."
+
+  ::Sequel::Database.send(:include, BaselineRedRpm::Instruments::SequelDatabase)
+  ::Sequel::Dataset.send(:include, BaselineRedRpm::Instruments::SequelDataset)
+
+  ::Sequel::Database.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+
+  ::Sequel::Dataset.class_eval do
+    alias_method :execute_without_trace, :execute
+    alias_method :execute, :execute_with_trace
+  end
+end

data/lib/baseline_red_rpm/instruments/sidekiq.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  class SidekiqServer
+    def call(*args)
+      worker, msg, queue = args
+
+      parent_span_context = extract(msg)
+      BaselineRedRpm::Tracer.sample!(parent_span_context)
+
+      if BaselineRedRpm::Tracer.tracing?
+        operation = "Sidekiq_#{queue}##{msg["wrapped"]}"
+        span = BaselineRedRpm.tracer.start_span(operation, :child_of => parent_span_context, tags: {
+          "component" => "Sidekiq",
+          "span.kind" => "server",
+          "http.url" => "/sidekiq/#{queue}/#{msg['wrapped']}",
+          "peer.address" => Socket.gethostname,
+          "bg.queue" => queue,
+          "bg.job_name" => worker.class.to_s
+        })
+        BaselineRedRpm::Utils.log_source_and_backtrace(span, :sidekiq)
+      end
+
+      yield
+    rescue Exception => e
+      if span
+        span.set_tag('error', true)
+        span.log_error(e)
+      end
+      raise
+    ensure
+      span.finish if span
+      BaselineRedRpm::Tracer.sample_off!
+    end
+
+    private
+
+    def extract(job)
+      carrier = job[BaselineRedRpm::TRACE_CONTEXT_KEY]
+      return unless carrier
+      BaselineRedRpm::tracer.extract(OpenTracing::FORMAT_TEXT_MAP, carrier)
+    end
+  end
+
+  class SidekiqClient
+    def call(*args)
+      worker, msg, queue = args
+
+      if ::BaselineRedRpm::Tracer.tracing?
+        operation = "Sidekiq_#{queue}##{msg["wrapped"]}"
+        span = BaselineRedRpm.tracer.start_span(operation, tags: {
+          "component" => "Sidekiq",
+          "span.kind" => "client",
+          "http.url" => "/sidekiq/#{queue}/#{msg['wrapped']}",
+          "peer.address" => Socket.gethostname,
+          "bg.queue" => queue,
+          "bg.job_name" => worker.class.to_s
+        })
+        BaselineRedRpm::Utils.log_source_and_backtrace(span, :sidekiq)
+
+        inject(span, msg)
+      end
+
+      yield
+    rescue Exception => e
+      if span
+        span.set_tag('error', true)
+        span.log_error(e)
+      end
+      raise
+    ensure
+      span.finish if span
+    end
+
+    private
+
+    def inject(span, job)
+      carrier = {}
+      BaselineRedRpm.tracer.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, carrier)
+      job[BaselineRedRpm::TRACE_CONTEXT_KEY] = carrier
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:sidekiq][:enabled] &&
+  defined?(::Sidekiq)
+  BaselineRedRpm.logger.info "Initializing sidekiq tracer."
+
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::BaselineRedRpm::SidekiqServer
+    end
+  end
+
+  ::Sidekiq.configure_client do |config|
+    config.client_middleware do |chain|
+      chain.add ::BaselineRedRpm::SidekiqClient
+    end
+  end
+end

data/lib/baseline_red_rpm/instruments/sinatra.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module Sinatra
+      module Base
+        def dispatch_with_trace
+          if ::BaselineRedRpm::Tracer.tracing?
+            operation = "#{self.class}##{env["PATH_INFO"]}"
+            span = ::BaselineRedRpm.tracer.start_span(operation, tags: {
+              component: "Sinatra"
+            })
+            BaselineRedRpm::Utils.log_source_and_backtrace(span, :sinatra)
+          end
+
+          dispatch_without_trace
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
+          end
+          raise
+        ensure
+          span.finish if span
+        end
+
+        def handle_exception_with_trace(boom)
+          handle_exception_without_trace(boom)
+        end
+      end
+
+      module Templates
+        def render_with_trace(engine, data, options = {}, locals = {}, &block)
+          if ::BaselineRedRpm::Tracer.tracing?
+            name = data
+
+            span = ::BaselineRedRpm.tracer.start_span("render", tags: {
+              "component" => "Sinatra",
+              "view.engine" => engine,
+              "view.name" => name,
+              "view.line_number" => __LINE__,
+              "view.template" => __FILE__
+            })
+            BaselineRedRpm::Utils.log_source_and_backtrace(span, :sinatra)
+          end
+
+          render_without_trace(engine, data, options, locals, &block)
+        rescue Exception => e
+          if span
+            span.set_tag('error', true)
+            span.log_error(e)
+          end
+          raise
+        ensure
+          span.finish if span
+        end
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:sinatra][:enabled] &&
+  defined?(::Sinatra)
+  ::BaselineRedRpm.logger.info "Initializing sinatra tracer."
+
+  ::Sinatra::Base.use BaselineRedRpm::Instruments::Rack
+
+  unless defined?(::Padrino)
+    ::Sinatra::Base.send(:include, ::BaselineRedRpm::Instruments::Sinatra::Base)
+    ::Sinatra::Base.class_eval do
+      alias_method :dispatch_without_trace, :dispatch!
+      alias_method :dispatch!, :dispatch_with_trace
+      alias_method :handle_exception_without_trace, :handle_exception!
+      alias_method :handle_exception!, :handle_exception_with_trace
+    end
+
+    ::Sinatra::Templates.send(:include, ::BaselineRedRpm::Instruments::Sinatra::Templates)
+    ::Sinatra::Base.class_eval do
+      alias_method :render_without_trace, :render
+    end
+  end
+end

data/lib/baseline_red_rpm/instruments/typhoeus.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BaselineRedRpm
+  module Instruments
+    module TyphoeusRequest
+      def run_with_trace
+        if ::BaselineRedRpm::Tracer.tracing?
+          span = ::BaselineRedRpm.tracer.start_span("typhoeus", tags: {
+            "component" => "Typhoeus"
+          })
+          BaselineRedRpm.tracer.inject(span.context, OpenTracing::FORMAT_RACK, options[:headers])
+
+          response = run_without_trace
+          span.exit
+          uri = URI(response.effective_url)
+
+          span.set_tag "http.status_code", response.code
+          span.set_tag "http.url", uri.to_s
+          span.set_tag "http.method", options[:method]
+          BaselineRedRpm::Utils.log_source_and_backtrace(span, :typhoeus)
+        else
+          response = run_without_trace
+        end
+        response
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+
+    module TyphoeusHydra
+      def run_with_trace
+        span = ::BaselineRedRpm.tracer.start_span("typhoeus", tags: {
+          "component" => "Typhoeus",
+          "method" => "hydra",
+          "http.queued_requests" => queued_requests.count,
+          "http.max_concurrency" => max_concurrency
+        })
+        BaselineRedRpm::Utils.log_source_and_backtrace(span, :typhoeus)
+
+        run_without_trace
+      rescue Exception => e
+        if span
+          span.set_tag('error', true)
+          span.log_error(e)
+        end
+        raise
+      ensure
+        span.finish if span
+      end
+    end
+  end
+end
+
+if ::BaselineRedRpm.config.instrumentation[:typhoeus][:enabled] && defined?(::Typhoeus)
+  ::BaselineRedRpm.logger.info "Initializing typhoeus tracer."
+
+  ::Typhoeus::Request::Operations.send(:include, BaselineRedRpm::Instruments::TyphoeusRequest)
+  ::Typhoeus::Request::Operations.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+
+  ::Typhoeus::Hydra.send(:include, BaselineRedRpm::Instruments::TyphoeusHydra)
+  ::Typhoeus::Hydra.class_eval do
+    alias_method :run_without_trace, :run
+    alias_method :run, :run_with_trace
+  end
+end