elastic-apm 0.1.0

data/lib/elastic_apm/sql_summarizer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class SqlSummarizer
+    REGEXES = {
+      /^SELECT .* FROM ([^ ]+)/i => 'SELECT FROM ',
+      /^INSERT INTO ([^ ]+)/i => 'INSERT INTO ',
+      /^UPDATE ([^ ]+)/i => 'UPDATE ',
+      /^DELETE FROM ([^ ]+)/i => 'DELETE FROM '
+    }.freeze
+
+    def self.cache
+      @cache ||= {}
+    end
+
+    def summarize(sql)
+      self.class.cache[sql] ||=
+        REGEXES.find do |regex, sig|
+          if (match = sql.match(regex))
+            break format("#{sig}#{match[1]}")
+          end
+        end
+    end
+  end
+end

data/lib/elastic_apm/stacktrace.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/stacktrace/frame'
+
+module ElasticAPM
+  # @api private
+  class Stacktrace
+    def initialize(backtrace)
+      @backtrace = backtrace
+    end
+
+    attr_reader :frames
+
+    def self.build(builder, backtrace)
+      return nil unless backtrace
+
+      stack = new(backtrace)
+      stack.build_frames(builder)
+      stack
+    end
+
+    def build_frames(builder)
+      @frames = @backtrace.reverse.map do |line|
+        build_frame(builder, line)
+      end
+    end
+
+    def length
+      frames.length
+    end
+
+    def to_a
+      frames.map(&:to_h)
+    end
+
+    private
+
+    JAVA_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/
+    RUBY_FORMAT = /^(.+?):(\d+)(?::in `(.+?)')?$/
+
+    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
+
+    def build_frame(_builder, line)
+      abs_path, lineno, function, _module_name = parse_line(line)
+
+      frame = Frame.new
+      frame.abs_path = abs_path
+      frame.filename = strip_load_path(abs_path)
+      frame.function = function
+      frame.lineno = lineno.to_i
+      frame.build_context 3
+
+      frame
+    end
+
+    def strip_load_path(path)
+      return nil unless path
+
+      prefix =
+        $LOAD_PATH
+        .map(&:to_s)
+        .select { |s| path.start_with?(s) }
+        .sort_by(&:length)
+        .last
+
+      return path unless prefix
+
+      path[prefix.chomp(File::SEPARATOR).length + 1..-1]
+    end
+  end
+end

data/lib/elastic_apm/stacktrace/frame.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Stacktrace
+    # @api private
+    class Frame
+      attr_accessor(
+        :abs_path,
+        :filename,
+        :function,
+        :vars,
+        :pre_context,
+        :context_line,
+        :post_context,
+        :in_app,
+        :lineno,
+        :module,
+        :colno
+      )
+
+      # rubocop:disable Metrics/AbcSize
+      def build_context(context_line_count)
+        return unless abs_path
+
+        file_lines = [nil] + read_lines(abs_path)
+
+        self.context_line = file_lines[lineno]
+        self.pre_context =
+          file_lines[(lineno - context_line_count - 1)...lineno]
+        self.post_context =
+          file_lines[(lineno + 1)..(lineno + context_line_count)]
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/MethodLength
+      def to_h
+        {
+          abs_path: abs_path,
+          filename: filename,
+          function: function,
+          vars: vars,
+          pre_context: pre_context,
+          context_line: context_line,
+          post_context: post_context,
+          in_app: in_app,
+          lineno: lineno,
+          module: self.module,
+          coln: colno
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def read_lines(path)
+        File.readlines(path)
+      rescue Errno::ENOENT
+        []
+      end
+    end
+  end
+end

data/lib/elastic_apm/subscriber.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+require 'elastic_apm/normalizers'
+
+module ElasticAPM
+  # @api private
+  class Subscriber
+    include Log
+
+    def initialize(agent)
+      @agent = agent
+      @config = agent.config
+      @normalizers = Normalizers.build(config)
+    end
+
+    attr_reader :config
+
+    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)
+
+    def start(name, id, payload)
+      # debug "AS::Notification#start:#{name}:#{id}"
+      return unless (transaction = @agent.current_transaction)
+
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      span =
+        if normalized == :skip
+          nil
+        else
+          name, type, context = normalized
+          transaction.span(name, type, context: context)
+        end
+
+      transaction.notifications << Notification.new(id, span)
+    end
+
+    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)
+          span.done
+        end
+        return
+      end
+    end
+
+    private
+
+    def notifications_regex
+      @notifications_regex ||= /(#{@normalizers.keys.join('|')})/
+    end
+  end
+end

data/lib/elastic_apm/system_info.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class SystemInfo
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
+
+    def build
+      {
+        hostname: `hostname`,
+        architecture: platform.cpu,
+        platform: platform.os
+      }
+    end
+
+    def self.build(config)
+      new(config).build
+    end
+
+    private
+
+    def platform
+      @platform ||= Gem::Platform.local
+    end
+  end
+end

data/lib/elastic_apm/transaction.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class Transaction
+    def initialize(instrumenter, name, type = 'custom')
+      @instrumenter = instrumenter
+      @name = name
+      @type = type
+
+      @timestamp = Util.micros
+
+      @spans = []
+      @notifications = []
+      @span_id_ticker = -1
+
+      @notifications = [] # for AS::Notifications
+
+      yield self if block_given?
+    end
+
+    attr_accessor :name, :result, :type
+    attr_reader :duration, :root_span, :timestamp, :spans, :notifications
+
+    def release
+      @instrumenter.current_transaction = nil
+    end
+
+    def done(result = nil)
+      @result = result
+
+      @duration = Util.micros - @timestamp
+
+      self
+    end
+
+    def done?
+      !!(@result && @duration)
+    end
+
+    def submit(result = nil)
+      done result
+
+      release
+
+      @instrumenter.submit_transaction self
+
+      self
+    end
+
+    def running_spans
+      spans.select(&:running?)
+    end
+
+    def span(name, type = nil, context: nil)
+      span = next_span(name, type, context)
+      spans << span
+      span.start
+
+      return span unless block_given?
+
+      begin
+        result = yield span
+      ensure
+        span.done
+      end
+
+      result
+    end
+
+    def current_span
+      spans.reverse.lazy.find(&:running?)
+    end
+
+    private
+
+    def next_span_id
+      @span_id_ticker += 1
+    end
+
+    def next_span(name, type, context)
+      Span.new(
+        self,
+        next_span_id,
+        name,
+        type,
+        parent: current_span,
+        context: context
+      )
+    end
+  end
+end

data/lib/elastic_apm/util.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Util
+    def self.nearest_minute(target = Time.now.utc)
+      target - target.to_i % 60
+    end
+
+    def self.micros(target = Time.now.utc)
+      target.to_i * 1_000_000 + target.usec
+    end
+
+    def self.inspect_transaction(transaction)
+      Inspector.new.transaction transaction
+    end
+  end
+end
+
+require 'elastic_apm/util/inspector'

data/lib/elastic_apm/util/inspector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Util
+    # @api private
+    class Inspector
+      def initialize(width = 80)
+        @width = width
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def transaction(transaction)
+        unless transaction.done?
+          raise ArgumentError, 'Transaction still running'
+        end
+
+        width_factor = @width.to_f / ms(transaction.duration)
+
+        lines = ['=' * @width]
+        lines << "[T] #{transaction.name} " \
+          "- #{transaction.type} (#{ms transaction.duration} ms)"
+        lines << "+#{'-' * (@width - 2)}+"
+
+        transaction.spans.each do |span|
+          indent = (ms(span.relative_start) * width_factor).to_i
+
+          if span.duration
+            span_width = ms(span.duration) * width_factor
+            duration_desc = ms(span.duration)
+          else
+            span_width = width - indent
+            duration_desc = 'RUNNING'
+          end
+
+          description = "[#{span.id}] " \
+            "#{span.name} - #{span.type} (#{duration_desc} ms)"
+          description_indent = [
+            0,
+            [indent, @width - description.length].min
+          ].max
+
+          lines << "#{' ' * description_indent}#{description}"
+          lines << "#{' ' * indent}+#{'-' * [(span_width - 2), 0].max}+"
+        end
+
+        lines.map { |s| s[0..@width] }.join("\n")
+      rescue StandardError => e
+        puts e
+        puts e.backspan.join("\n")
+        nil
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def ms(micros)
+        micros.to_f / 1_000
+      end
+    end
+  end
+end