elastic-apm 0.1.0

data/lib/elastic_apm/error/context.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Error
+    # @api private
+    class Context
+      # @api private
+      class Request
+        def initialize
+          @socket = {}
+          @headers = {}
+          @cookies = {}
+          @env = {}
+        end
+
+        attr_accessor(
+          :socket,
+          :http_version,
+          :method,
+          :url,
+          :headers,
+          :cookies,
+          :env,
+          :body
+        )
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def add_rack_env(rack_env)
+          req = rails_req?(rack_env) ? rack_env : Rack::Request.new(rack_env)
+
+          self.socket = {
+            remote_address: req.ip,
+            encrypted: req.scheme == 'https'
+          }
+          http_version = rack_env['HTTP_VERSION']
+          self.http_version =
+            http_version && http_version.gsub(%r{HTTP/}, '')
+          self.method = req.request_method
+          self.url = {
+            protocol: req.scheme,
+            hostname: req.host,
+            port: req.port,
+            pathname: req.path,
+            search: req.query_string,
+            hash: nil,
+            raw: req.fullpath
+          }
+
+          add_headers(rack_env)
+          add_body(req)
+
+          self
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        def self.from_rack_env(rack_env)
+          request = new
+          request.add_rack_env rack_env
+          request
+        end
+
+        private
+
+        def add_body(req)
+          if req.form_data?
+            self.body = req.POST
+          else
+            self.body = req.body.read
+            req.body.rewind
+          end
+        end
+
+        def rails_req?(env)
+          defined?(ActionDispatch::Request) &&
+            env.is_a?(ActionDispatch::Request)
+        end
+
+        def add_headers(rack_env)
+          get_headers(rack_env).each do |key, value|
+            next unless key.upcase == key
+
+            if key.start_with?('HTTP_')
+              headers[camel_key(key)] = value
+            else
+              env[key] = value
+            end
+          end
+        end
+
+        def camel_key(key)
+          key.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+        end
+
+        def get_headers(rack_env)
+          # In Rails < 5 ActionDispatch::Request inherits from Hash
+          rack_env.respond_to?(:headers) ? rack_env.headers : rack_env
+        end
+      end
+
+      # @api private
+      class Response
+        attr_accessor(
+          :status_code,
+          :headers,
+          :headers_sent,
+          :finished
+        )
+      end
+
+      attr_accessor(
+        :request,
+        :response,
+        :user,
+        :tags,
+        :custom
+      )
+    end
+  end
+end

data/lib/elastic_apm/error/exception.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Error
+    # @api private
+    class Exception
+      MOD_SPLIT = '::'.freeze
+
+      def initialize(exception, **attrs)
+        @message =
+          "#{exception.class}: #{exception.message}"
+        @type = exception.class.to_s
+        @module = format_module exception
+
+        attrs.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      attr_accessor(
+        :attributes,
+        :code,
+        :handled,
+        :message,
+        :module,
+        :stacktrace,
+        :type
+      )
+
+      private
+
+      def format_module(exception)
+        exception.class.to_s.split(MOD_SPLIT)[0...-1].join(MOD_SPLIT)
+      end
+    end
+  end
+end

data/lib/elastic_apm/error/log.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Error
+    # @api private
+    class Log
+      def initialize(message, attrs = {})
+        @message = message
+
+        attrs.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      attr_accessor(
+        :level,
+        :logger_name,
+        :message,
+        :param_message,
+        :stacktrace
+      )
+    end
+  end
+end

data/lib/elastic_apm/error_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class ErrorBuilder
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
+
+    def build_exception(exception, rack_env: nil, handled: true)
+      error = Error.new
+      error.exception = Error::Exception.new(exception, handled: handled)
+
+      if (stacktrace = Stacktrace.build(config, exception.backtrace))
+        error.exception.stacktrace = stacktrace
+        error.culprit = stacktrace.frames.last.function
+      end
+
+      if rack_env
+        error.context.request = Error::Context::Request.from_rack_env rack_env
+      end
+
+      error
+    end
+
+    def build_log(message, backtrace: nil, **attrs)
+      error = Error.new
+      error.log = Error::Log.new(message, **attrs)
+
+      if (stacktrace = Stacktrace.build(config, backtrace))
+        error.log.stacktrace = stacktrace
+        error.culprit = stacktrace.frames.last.function
+      end
+
+      error
+    end
+  end
+end

data/lib/elastic_apm/http.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+require 'elastic_apm/service_info'
+require 'elastic_apm/system_info'
+
+module ElasticAPM
+  # @api private
+  class Http
+    include Log
+
+    USER_AGENT = "elastic-apm/ruby #{VERSION}".freeze
+    ACCEPT = 'application/json'.freeze
+    CONTENT_TYPE = 'application/json'.freeze
+
+    def initialize(config, adapter: HttpAdapter)
+      @config = config
+      @adapter = adapter.new(config)
+      @base_payload = {
+        service: ServiceInfo.build(config),
+        system: SystemInfo.build(config)
+      }
+    end
+
+    attr_reader :config
+
+    def post(path, payload = {})
+      payload.merge! @base_payload
+      request = prepare_request path, payload.to_json
+      response = @adapter.perform request
+
+      status = response.code.to_i
+      return response if status >= 200 && status <= 299
+
+      error "POST returned an unsuccessful status code (#{response.code})"
+      debug response.body
+
+      response
+    end
+
+    private
+
+    def prepare_request(path, data)
+      @adapter.post url_for(path) do |req|
+        req['Accept'] = ACCEPT
+        req['Content-Type'] = CONTENT_TYPE
+        req['User-Agent'] = USER_AGENT
+        req['Content-Length'] = data.bytesize.to_s
+
+        if (token = config.secret_token)
+          req['Authorization'] = "Bearer #{token}"
+        end
+
+        req.body = data
+      end
+    end
+
+    def url_for(path)
+      "#{@config.server}#{path}"
+    end
+  end
+
+  # @api private
+  class HttpAdapter
+    def initialize(conf)
+      @config = conf
+    end
+
+    def post(path)
+      req = Net::HTTP::Post.new path
+      yield req if block_given?
+      req
+    end
+
+    def perform(req)
+      http.start do |http|
+        http.request req
+      end
+    end
+
+    private
+
+    def http
+      return @http if @http
+
+      http = Net::HTTP.new server_uri.host, server_uri.port
+      http.use_ssl = @config.use_ssl?
+      http.read_timeout = @config.timeout
+      http.open_timeout = @config.open_timeout
+
+      if @config.debug_http
+        http.set_debug_output(@config.logger)
+      end
+
+      @http = http
+    end
+
+    def server_uri
+      @uri ||= URI(@config.server)
+    end
+  end
+end

data/lib/elastic_apm/injectors.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class Registration
+      def initialize(const_name, require_paths, injector)
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @injector = injector
+      end
+
+      attr_reader :const_name, :require_paths, :injector
+
+      def install
+        injector.install
+      end
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.register(*args)
+      registration = Registration.new(*args)
+
+      if const_defined?(registration.const_name)
+        installed[registration.const_name] = registration
+        registration.install
+      else
+        register_require_hook registration
+      end
+    end
+
+    def self.register_require_hook(registration)
+      registration.require_paths.each do |path|
+        require_hooks[path] = registration
+      end
+    end
+
+    def self.const_defined?(const_name)
+      const = ActiveSupport::Inflector.constantize(const_name)
+      !!const
+    rescue NameError
+      false
+    end
+  end
+end
+
+# @api private
+module Kernel
+  alias require_without_apm require
+
+  def require(path)
+    res = require_without_apm(path)
+
+    begin
+      ElasticAPM::Injectors.hook_into(path)
+    rescue ::Exception # rubocop:disable Lint/HandleExceptions
+    end
+
+    res
+  end
+end

data/lib/elastic_apm/injectors/action_dispatch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class ActionDispatchInjector
+      def install
+        ::ActionDispatch::ShowExceptions.class_eval do
+          alias render_exception_without_apm render_exception
+
+          def render_exception(env, exception)
+            ElasticAPM.report(exception, rack_env: env)
+            render_exception_without_apm env, exception
+          end
+        end
+      end
+    end
+
+    register(
+      'ActionDispatch::ShowExceptions',
+      'action_dispatch/show_exception',
+      ActionDispatchInjector.new
+    )
+  end
+end

data/lib/elastic_apm/injectors/json.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/span_helpers'
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class JSONInjector
+      def install
+        ::JSON.class_eval do
+          include SpanHelpers
+          span_class_method :parse, 'JSON#parse', 'json.parse'
+          span_class_method :parse!, 'JSON#parse!', 'json.parse'
+          span_class_method :generate, 'JSON#generate', 'json.generate'
+        end
+      end
+    end
+
+    register 'JSON', 'json', JSONInjector.new
+  end
+end