elastic-apm 0.1.0

data/lib/elastic_apm/normalizers/action_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Normalizers
+    module ActionController
+      # @api private
+      class ProcessActionNormalizer < Normalizer
+        register 'process_action.action_controller'
+        TYPE = 'app.controller.action'.freeze
+
+        def normalize(transaction, _name, payload)
+          transaction.name = endpoint(payload)
+          [transaction.name, TYPE, nil]
+        end
+
+        private
+
+        def endpoint(payload)
+          "#{payload[:controller]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/normalizers/action_view.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Normalizers
+    module ActionView
+      # @api private
+      class RenderNormalizer < Normalizer
+        private
+
+        def normalize_render(payload, type)
+          [path_for(payload[:identifier]), type, nil]
+        end
+
+        def path_for(path)
+          return 'Unknown template' unless path
+          return path unless path.start_with?('/')
+
+          view_path(path) || gem_path(path) || 'Absolute path'
+        end
+
+        def view_path(path)
+          root = @config.view_paths.find { |vp| path.start_with?(vp) }
+          return unless root
+
+          strip_root(root, path)
+        end
+
+        def gem_path(path)
+          root = Gem.path.find { |gp| path.start_with? gp }
+          return unless root
+
+          format '$GEM_PATH/%s', strip_root(root, path)
+        end
+
+        def strip_root(root, path)
+          start = root.length + 1
+          path[start, path.length]
+        end
+      end
+
+      # @api private
+      class RenderTemplateNormalizer < RenderNormalizer
+        register 'render_template.action_view'
+        TYPE = 'template.view'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+
+      # @api private
+      class RenderPartialNormalizer < RenderNormalizer
+        register 'render_partial.action_view'
+        TYPE = 'template.view.partial'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+
+      # @api private
+      class RenderCollectionNormalizer < RenderNormalizer
+        register 'render_collection.action_view'
+        TYPE = 'template.view.collection'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/normalizers/active_record.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/sql_summarizer'
+
+module ElasticAPM
+  module Normalizers
+    module ActiveRecord
+      # @api private
+      class SqlNormalizer < Normalizer
+        register 'sql.active_record'
+
+        def initialize(*args)
+          super(*args)
+
+          @type = format('db.%s.sql', lookup_adapter || 'unknown').freeze
+          @summarizer = SqlSummarizer.new
+        end
+
+        def normalize(_transaction, _name, payload)
+          return :skip if %w[SCHEMA CACHE].include?(payload[:name])
+
+          name = summarize(payload[:sql]) || payload[:name] || 'SQL'
+          context = Span::Context.new(statement: payload[:sql])
+          [name, @type, context]
+        end
+
+        private
+
+        def summarize(sql)
+          @summarizer.summarize(sql)
+        end
+
+        def lookup_adapter
+          ::ActiveRecord::Base.connection.adapter_name.downcase
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/railtie.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class Railtie < Rails::Railtie
+    config.elastic_apm = ActiveSupport::OrderedOptions.new
+    Config::DEFAULTS.each { |option, value| config.elastic_apm[option] = value }
+
+    initializer 'elastic_apm.initialize' do |app|
+      config = Config.new app.config.elastic_apm do |c|
+        c.app = app
+      end
+
+      file_config = load_config(app)
+      file_config.each do |option, value|
+        config.send(:"#{option}=", value)
+      end
+
+      begin
+        ElasticAPM.start config
+        Rails.logger.info "#{Log::PREFIX}Running"
+
+        app.middleware.insert 0, Middleware
+      rescue StandardError => e
+        Rails.logger.error "#{Log::PREFIX}Failed to start: #{e.message}"
+        Rails.logger.debug e.backtrace.join("\n")
+      end
+    end
+
+    config.after_initialize do
+      require 'elastic_apm/injectors/action_dispatch'
+    end
+
+    private
+
+    def load_config(app)
+      config_path = app.root.join('config', 'elastic_apm.yml')
+      return {} unless File.exist?(config_path)
+
+      YAML.load_file(config_path) || {}
+    end
+  end
+end

data/lib/elastic_apm/serializers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Serializers
+    # @api private
+    class Serializer
+      def initialize(config)
+        @config = config
+      end
+
+      private
+
+      def micros_to_time(micros)
+        Time.at(ms(micros) / 1_000)
+      end
+
+      def ms(micros)
+        micros.to_f / 1_000
+      end
+    end
+  end
+end
+
+require 'elastic_apm/serializers/transactions'
+require 'elastic_apm/serializers/errors'

data/lib/elastic_apm/serializers/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Serializers
+    # @api private
+    class Errors < Serializer
+      def build(error)
+        base = {
+          id: SecureRandom.uuid,
+          culprit: error.culprit,
+          timestamp: micros_to_time(error.timestamp).utc.iso8601
+        }
+
+        if (exception = error.exception)
+          base[:exception] = build_exception exception
+        end
+
+        base
+      end
+
+      def build_all(errors)
+        { errors: Array(errors).map(&method(:build)) }
+      end
+
+      private
+
+      def build_exception(exception)
+        {
+          message: exception.message,
+          type: exception.type,
+          module: exception.module,
+          code: exception.code,
+          attributes: exception.attributes,
+          stacktrace: exception.stacktrace.to_a,
+          unhandled: !exception.handled
+        }
+      end
+    end
+  end
+end

data/lib/elastic_apm/serializers/transactions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  module Serializers
+    # @api private
+    class Transactions < Serializer
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def build(transaction)
+        {
+          id: SecureRandom.uuid,
+          name: transaction.name,
+          type: transaction.type,
+          result: transaction.result.to_s,
+          duration: ms(transaction.duration),
+          timestamp: micros_to_time(transaction.timestamp).utc.iso8601,
+          spans: transaction.spans.map do |span|
+            {
+              id: span.id,
+              parent: span.parent && span.parent.id,
+              name: span.name,
+              type: span.type,
+              start: ms(span.relative_start),
+              duration: ms(span.duration),
+              context: span.context && { db: span.context.to_h }
+            }
+          end
+        }
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def build_all(transactions)
+        { transactions: Array(transactions).map(&method(:build)) }
+      end
+    end
+  end
+end

data/lib/elastic_apm/service_info.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class ServiceInfo
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
+
+    # rubocop:disable Metrics/MethodLength
+    def build
+      base = {
+        name: config.app_name,
+        environment: config.environment,
+        agent: {
+          name: 'ruby',
+          version: VERSION
+        },
+        framework: nil,
+        argv: ARGV,
+        language: {
+          name: 'ruby',
+          version: RUBY_VERSION
+        },
+        pid: $PID,
+        process_title: $PROGRAM_NAME,
+        runtime: runtime,
+        version: git_sha
+      }
+
+      if config.framework_name
+        base[:framework] = {
+          name: config.framework_name,
+          version: config.framework_version
+        }
+      end
+
+      base
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.build(config)
+      new(config).build
+    end
+
+    private
+
+    def git_sha
+      sha = `git rev-parse --verify HEAD 2>&1`.chomp
+      return sha if $?.success? # rubocop:disable Style/SpecialGlobalVars
+
+      nil
+    end
+
+    def runtime
+      case RUBY_ENGINE
+      when 'ruby'
+        { name: RUBY_ENGINE, version: RUBY_VERSION }
+      when 'jruby'
+        { name: RUBY_ENGINE, version: ENV['JRUBY_VERSION'] }
+      end
+    end
+  end
+end

data/lib/elastic_apm/span.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/span/context'
+
+module ElasticAPM
+  # @api private
+  class Span
+    DEFAULT_KIND = 'custom'.freeze
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      transaction,
+      id,
+      name,
+      type = DEFAULT_KIND,
+      parent: nil,
+      context: nil
+    )
+      @transaction = transaction
+      @id = id
+      @name = name
+      @type = type
+      @parent = parent
+      @context = context
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    attr_accessor :name, :context, :type
+    attr_reader :id, :duration, :parent, :relative_start
+
+    def start
+      @relative_start = Util.micros - @transaction.timestamp
+
+      self
+    end
+
+    def done
+      @duration = Util.micros - @transaction.timestamp - relative_start
+
+      self
+    end
+
+    def done?
+      !!duration
+    end
+
+    def running?
+      relative_start && !done?
+    end
+  end
+end

data/lib/elastic_apm/span/context.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Span
+    # @api private
+    class Context
+      def initialize(**args)
+        args.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      attr_accessor :instance, :statement, :type, :user
+
+      def to_h
+        { instance: instance, statement: statement, type: type, user: user }
+      end
+    end
+  end
+end

data/lib/elastic_apm/span_helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module SpanHelpers
+    # @api private
+    module ClassMethods
+      def span_class_method(method, name, type)
+        __span_method_on(singleton_class, method, name, type)
+      end
+
+      private
+
+      def __span_method_on(klass, method, name, type)
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias :"__without_apm_#{method}" :"#{method}"
+
+          def #{method}(*args, &block)
+            unless ElasticAPM.current_transaction
+              return __without_apm_#{method}(*args, &block)
+            end
+
+            ElasticAPM.span "#{name}", "#{type}" do
+              __without_apm_#{method}(*args, &block)
+            end
+          end
+        RUBY
+      end
+    end
+
+    def self.included(kls)
+      kls.class_eval do
+        extend ClassMethods
+      end
+    end
+  end
+end