atatus 1.0.0

data/lib/atatus/spies/sidekiq.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class SidekiqSpy
+      ACTIVE_JOB_WRAPPER =
+        'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'
+
+      # @api private
+      class Middleware
+        # rubocop:disable Metrics/MethodLength
+        def call(_worker, job, queue)
+          name = SidekiqSpy.name_for(job)
+          transaction = Atatus.start_transaction(name, 'Sidekiq')
+          Atatus.set_label(:queue, queue)
+
+          yield
+
+          transaction.done :success if transaction
+        rescue ::Exception => e
+          Atatus.report(e, handled: false)
+          transaction.done :error if transaction
+          raise
+        ensure
+          Atatus.end_transaction
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      def self.name_for(job)
+        klass = job['class']
+
+        case klass
+        when ACTIVE_JOB_WRAPPER
+          job['wrapped']
+        else
+          klass
+        end
+      end
+
+      def install_middleware
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Middleware
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def install_processor
+        require 'sidekiq/processor'
+
+        Sidekiq::Processor.class_eval do
+          alias start_without_apm start
+          alias terminate_without_apm terminate
+
+          def start
+            result = start_without_apm
+
+            # Already running from Railtie if Rails
+            if Atatus.running?
+              Atatus.agent.config.logger = Sidekiq.logger
+            else
+              Atatus.start
+            end
+
+            result
+          end
+
+          def terminate
+            terminate_without_apm
+
+            Atatus.stop
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def install
+        install_processor
+        install_middleware
+      end
+    end
+
+    register 'Sidekiq', 'sidekiq', SidekiqSpy.new
+  end
+end

data/lib/atatus/spies/sinatra.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class SinatraSpy
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::Sinatra::Base.class_eval do
+          alias dispatch_without_apm! dispatch!
+          alias compile_template_without_apm compile_template
+
+          def dispatch!(*args, &block)
+            dispatch_without_apm!(*args, &block).tap do
+              next unless (transaction = Atatus.current_transaction)
+              next unless (route = env['sinatra.route'])
+
+              transaction.name = route
+            end
+          end
+
+          def compile_template(engine, data, opts, *args, &block)
+            opts[:__atatus_template_name] =
+              case data
+              when Symbol then data.to_s
+              else format('Inline %s', engine)
+              end
+
+            compile_template_without_apm(engine, data, opts, *args, &block)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'Sinatra::Base', 'sinatra/base', SinatraSpy.new
+
+    require 'atatus/spies/tilt'
+  end
+end

data/lib/atatus/spies/tilt.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class TiltSpy
+      TYPE = 'template.tilt'
+
+      def install
+        ::Tilt::Template.class_eval do
+          alias render_without_apm render
+
+          def render(*args, &block)
+            name = options[:__atatus_template_name] || 'Unknown template'
+
+            Atatus.with_span name, TYPE do
+              render_without_apm(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Tilt::Template', 'tilt/template', TiltSpy.new
+  end
+end

data/lib/atatus/sql_summarizer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'atatus/util/lru_cache'
+
+module Atatus
+  # @api private
+  class SqlSummarizer
+    DEFAULT = 'SQL'
+    TABLE_REGEX = %{["'`]?([A-Za-z0-9_]+)["'`]?}
+
+    REGEXES = {
+      /^BEGIN/i => 'BEGIN',
+      /^COMMIT/i => 'COMMIT',
+      /^SELECT .* FROM #{TABLE_REGEX}/i => 'SELECT FROM ',
+      /^INSERT INTO #{TABLE_REGEX}/i => 'INSERT INTO ',
+      /^UPDATE #{TABLE_REGEX}/i => 'UPDATE ',
+      /^DELETE FROM #{TABLE_REGEX}/i => 'DELETE FROM '
+    }.freeze
+
+    FORMAT = '%s%s'
+
+    def self.cache
+      @cache ||= Util::LruCache.new
+    end
+
+    def summarize(sql)
+      self.class.cache[sql] ||=
+        REGEXES.find do |regex, sig|
+          if (match = sql[0...1000].match(regex))
+            break format(FORMAT, sig, match[1] && match[1].gsub(/["']/, ''))
+          end
+        end || DEFAULT
+    end
+  end
+end

data/lib/atatus/stacktrace.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Stacktrace
+    attr_accessor :frames
+
+    def length
+      frames.length
+    end
+
+    def to_a
+      frames.map(&:to_h)
+    end
+  end
+end

data/lib/atatus/stacktrace/frame.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'atatus/naively_hashable'
+
+module Atatus
+  class Stacktrace
+    # @api private
+    class Frame
+      include NaivelyHashable
+
+      attr_accessor(
+        :abs_path,
+        :filename,
+        :function,
+        :vars,
+        :pre_context,
+        :context_line,
+        :post_context,
+        :library_frame,
+        :lineno,
+        :module,
+        :colno
+      )
+
+      # rubocop:disable Metrics/AbcSize
+      def build_context(context_line_count)
+        return unless abs_path && context_line_count > 0
+
+        padding = (context_line_count - 1) / 2
+        from = lineno - padding - 1
+        from = 0 if from < 0
+        to = lineno + padding - 1
+        file_lines = read_lines(abs_path, from..to)
+
+        return unless file_lines
+
+        self.context_line = file_lines[padding]
+        self.pre_context  = file_lines.first(padding)
+        self.post_context = file_lines.last(padding)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def read_lines(path, range)
+        File.readlines(path)[range]
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/atatus/stacktrace_builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'atatus/stacktrace/frame'
+require 'atatus/util/lru_cache'
+
+module Atatus
+  # @api private
+  class StacktraceBuilder
+    JAVA_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/.freeze
+    RUBY_FORMAT = /^(.+?):(\d+)(?::in `(.+?)')?$/.freeze
+
+    RUBY_VERS_REGEX = %r{ruby(/gems)?[-/](\d+\.)+\d}.freeze
+    JRUBY_ORG_REGEX = %r{org/jruby}.freeze
+
+    GEMS_PATH = defined?(Bundler) ? Bundler.bundle_path.to_s : Gem.dir
+
+    def initialize(config)
+      @config = config
+      @cache = Util::LruCache.new(2048, &method(:build_frame))
+    end
+
+    attr_reader :config
+
+    def build(backtrace, type:)
+      Stacktrace.new.tap do |s|
+        s.frames = backtrace[0...config.stack_trace_limit].map do |line|
+          @cache[[line, type]]
+        end
+      end
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def build_frame(cache, keys)
+      line, type = keys
+      abs_path, lineno, function, _module_name = parse_line(line)
+
+      frame = Stacktrace::Frame.new
+      frame.abs_path = abs_path
+      frame.filename = strip_load_path(abs_path)
+      frame.function = function
+      frame.lineno = lineno.to_i
+      frame.library_frame = library_frame?(config, abs_path)
+
+      line_count =
+        context_lines_for(config, type, library_frame: frame.library_frame)
+      frame.build_context line_count
+
+      cache[[line, type]] = frame
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def parse_line(line)
+      ruby_match = line.match(RUBY_FORMAT)
+
+      if ruby_match
+        _, file, number, method = ruby_match.to_a
+        file.sub!(/\.class$/, '.rb')
+        module_name = nil
+      else
+        java_match = line.match(JAVA_FORMAT)
+        _, module_name, method, file, number = java_match.to_a
+      end
+
+      [file, number, method, module_name]
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def library_frame?(config, abs_path)
+      return false unless abs_path
+
+      return true if abs_path.start_with?(GEMS_PATH)
+
+      if abs_path.start_with?(config.__root_path)
+        return true if abs_path.start_with?(config.__root_path + '/vendor')
+        return false
+      end
+
+      return true if abs_path.match(RUBY_VERS_REGEX)
+      return true if abs_path.match(JRUBY_ORG_REGEX)
+
+      false
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def strip_load_path(path)
+      return nil if path.nil?
+
+      prefix =
+        $LOAD_PATH
+        .map(&:to_s)
+        .select { |s| path.start_with?(s) }
+        .max_by(&:length)
+
+      prefix ? path[prefix.chomp(File::SEPARATOR).length + 1..-1] : path
+    end
+
+    def context_lines_for(config, type, library_frame:)
+      key = "source_lines_#{type}_#{library_frame ? 'library' : 'app'}_frames"
+      config.send(key.to_sym)
+    end
+  end
+end

data/lib/atatus/subscriber.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+require 'atatus/normalizers'
+
+module Atatus
+  # @api private
+  class Subscriber
+    include Logging
+
+    def initialize(agent)
+      @agent = agent
+      @normalizers = Normalizers.build(agent.config)
+    end
+
+    def register!
+      unregister! if @subscription
+
+      @subscription =
+        ActiveSupport::Notifications.subscribe(notifications_regex, self)
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscription
+      @subscription = nil
+    end
+
+    # AS::Notifications API
+
+    Notification = Struct.new(:id, :span)
+
+    # rubocop:disable Metrics/MethodLength
+    def start(name, id, payload)
+      return unless (transaction = @agent.current_transaction)
+
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      span =
+        if normalized == :skip
+          nil
+        else
+          name, type, subtype, action, context = normalized
+
+          @agent.start_span(
+            name,
+            type,
+            subtype: subtype,
+            action: action,
+            context: context
+          )
+        end
+
+      transaction.notifications << Notification.new(id, span)
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def finish(_name, id, _payload)
+      # debug "AS::Notification#finish:#{name}:#{id}"
+      return unless (transaction = @agent.current_transaction)
+
+      while (notification = transaction.notifications.pop)
+        next unless notification.id == id
+
+        if (span = notification.span)
+          @agent.end_span if span == @agent.current_span
+        end
+        return
+      end
+    end
+
+    private
+
+    def notifications_regex
+      @notifications_regex ||= /(#{@normalizers.keys.join('|')})/
+    end
+  end
+end