elastic-apm 0.1.0 → 0.2.0

data/lib/elastic_apm/agent.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'elastic_apm/naively_hashable'
+require 'elastic_apm/context_builder'
 require 'elastic_apm/error_builder'
 require 'elastic_apm/error'
 require 'elastic_apm/http'
@@ -51,6 +53,7 @@ module ElasticAPM
       @queue = Queue.new
 
       @instrumenter = Instrumenter.new(config, self)
+      @context_builder = ContextBuilder.new(config)
       @error_builder = ErrorBuilder.new(config)
 
       @serializers = Struct.new(:transactions, :errors).new(
@@ -59,10 +62,10 @@ module ElasticAPM
       )
     end
 
-    attr_reader :config, :queue, :instrumenter
+    attr_reader :config, :queue, :instrumenter, :context_builder
 
     def start
-      debug 'Starting agent reporting to %s', config.server
+      debug 'Starting agent reporting to %s', config.server_url
 
       @instrumenter.start
 
@@ -114,12 +117,15 @@ module ElasticAPM
       instrumenter.span(*args, &block)
     end
 
+    def build_context(rack_env)
+      @context_builder.build(rack_env)
+    end
+
     # errors
 
-    def report(exception, rack_env: nil, handled: true)
+    def report(exception, handled: true)
       error = @error_builder.build_exception(
         exception,
-        rack_env: rack_env,
         handled: handled
       )
       enqueue_errors error
@@ -134,6 +140,16 @@ module ElasticAPM
       enqueue_errors error
     end
 
+    # context
+
+    def set_tag(*args)
+      instrumenter.set_tag(*args)
+    end
+
+    def set_custom_context(*args)
+      instrumenter.set_custom_context(*args)
+    end
+
     def inspect
       '<ElasticAPM::Agent>'
     end

data/lib/elastic_apm/config.rb

@@ -6,7 +6,7 @@ module ElasticAPM
   # @api private
   class Config
     DEFAULTS = {
-      server: 'http://localhost:8200',
+      server_url: 'http://localhost:8200',
       secret_token: nil,
 
       app_name: nil,
@@ -25,6 +25,11 @@ module ElasticAPM
 
       enabled_injectors: %w[net_http],
 
+      current_user_method: :current_user,
+      current_user_id_method: :id,
+      current_user_email_method: :email,
+      current_user_username_method: :username,
+
       view_paths: []
     }.freeze
 
@@ -42,7 +47,7 @@ module ElasticAPM
       yield self
     end
 
-    attr_accessor :server
+    attr_accessor :server_url
     attr_accessor :secret_token
 
     attr_accessor :app_name
@@ -63,6 +68,11 @@ module ElasticAPM
 
     attr_accessor :view_paths
 
+    attr_accessor :current_user_method
+    attr_accessor :current_user_id_method
+    attr_accessor :current_user_email_method
+    attr_accessor :current_user_username_method
+
     attr_writer :logger
 
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
@@ -78,6 +88,9 @@ module ElasticAPM
         self.framework_version = Rails::VERSION::STRING
         self.logger = Rails.logger
         self.view_paths = app.config.paths['app/views'].existent
+      else
+        # TODO: define custom?
+        self.app_name = 'ruby'
       end
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
@@ -106,7 +119,7 @@ module ElasticAPM
     end
 
     def use_ssl?
-      server.start_with?('https')
+      server_url.start_with?('https')
     end
 
     private

data/lib/elastic_apm/context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/context/request'
+require 'elastic_apm/context/request/socket'
+require 'elastic_apm/context/request/url'
+require 'elastic_apm/context/response'
+require 'elastic_apm/context/user'
+
+module ElasticAPM
+  # @api private
+  class Context
+    include NaivelyHashable
+
+    attr_accessor :request, :response, :user
+    attr_reader :custom, :tags
+
+    def initialize
+      @custom = {}
+      @tags = {}
+    end
+  end
+end

data/lib/elastic_apm/context/request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Context
+    # @api private
+    class Request
+      include NaivelyHashable
+
+      attr_accessor :body, :cookies, :env, :headers, :http_version, :method,
+        :socket, :url
+    end
+  end
+end

data/lib/elastic_apm/context/request/socket.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Socket
+        include NaivelyHashable
+
+        def initialize(req)
+          @remote_addr = req.ip
+          @encrypted = req.scheme == 'https'
+        end
+
+        attr_reader :remote_addr, :encrypted
+      end
+    end
+  end
+end

data/lib/elastic_apm/context/request/url.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Url
+        include NaivelyHashable
+
+        SKIPPED_PORTS = {
+          'http' => 80,
+          'https' => 443
+        }.freeze
+
+        def initialize(req)
+          @protocol = req.scheme
+          @hostname = req.host
+          @port = req.port.to_s
+          @pathname = req.path
+          @search = req.query_string
+          @hash = nil
+          @full = build_full_url req
+        end
+
+        attr_reader :protocol, :hostname, :port, :pathname, :search, :hash,
+          :full
+
+        private
+
+        def build_full_url(req)
+          url = "#{req.scheme}://#{req.host}"
+
+          if req.port != SKIPPED_PORTS[req.scheme]
+            url += ":#{req.port}"
+          end
+
+          url + req.fullpath
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/context/response.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Context
+    # @api private
+    class Response
+      include NaivelyHashable
+
+      def initialize(
+        status_code,
+        headers: {},
+        headers_sent: true,
+        finished: true
+      )
+        @status_code = status_code
+        @headers = headers
+        @headers_sent = headers_sent
+        @finished = finished
+      end
+
+      attr_accessor :status_code, :headers, :headers_sent, :finished
+    end
+  end
+end

data/lib/elastic_apm/context/user.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Context
+    # @api private
+    class User
+      include NaivelyHashable
+
+      def initialize(config, record)
+        return unless record
+
+        @id = safe_get(record, config.current_user_id_method)
+        @email = safe_get(record, config.current_user_email_method)
+        @username = safe_get(record, config.current_user_username_method)
+      end
+
+      attr_accessor :id, :email, :username
+
+      private
+
+      def safe_get(record, method_name)
+        record.respond_to?(method_name) ? record.send(method_name) : nil
+      end
+    end
+  end
+end

data/lib/elastic_apm/context_builder.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class ContextBuilder
+    CONTROLLER_KEY = 'action_controller.instance'.freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    attr_reader :config
+
+    def build(rack_env)
+      context = Context.new
+
+      apply_to_request(context, rack_env)
+      apply_to_user(context, rack_env)
+
+      context
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def apply_to_request(context, rack_env)
+      req = rails_req?(rack_env) ? rack_env : Rack::Request.new(rack_env)
+
+      context.request = Context::Request.new unless context.request
+      request = context.request
+
+      request.socket = Context::Request::Socket.new(req).to_h
+      request.http_version = build_http_version rack_env
+      request.method = req.request_method
+      request.url = Context::Request::Url.new(req).to_h
+      request.headers, request.env = get_headers_and_env(rack_env)
+      request.body = get_body(req)
+
+      context
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def apply_to_user(context, rack_env)
+      return unless (controller = rack_env[CONTROLLER_KEY])
+
+      method = config.current_user_method.to_sym
+      return unless controller.respond_to?(method)
+
+      return unless (record = controller.send method)
+
+      context.user = Context::User.new(config, record)
+      context
+    end
+
+    def get_body(req)
+      return req.POST if req.form_data?
+
+      body = req.body.read
+      req.body.rewind
+      body
+    end
+
+    def rails_req?(env)
+      defined?(ActionDispatch::Request) &&
+        env.is_a?(ActionDispatch::Request)
+    end
+
+    def get_headers_and_env(rack_env)
+      # In Rails < 5 ActionDispatch::Request inherits from Hash
+      headers =
+        rack_env.respond_to?(:headers) ? rack_env.headers : rack_env
+
+      headers.each_with_object([{}, {}]) do |(key, value), (http, env)|
+        next unless key == key.upcase
+
+        if key.start_with?('HTTP_')
+          http[camel_key(key)] = value
+        else
+          env[key] = value
+        end
+      end
+    end
+
+    def camel_key(key)
+      key.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+    end
+
+    def build_http_version(rack_env)
+      return unless (http_version = rack_env['HTTP_VERSION'])
+      http_version.gsub(%r{HTTP/}, '')
+    end
+  end
+end

data/lib/elastic_apm/error.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 require 'elastic_apm/stacktrace'
+require 'elastic_apm/context'
 require 'elastic_apm/error/exception'
 require 'elastic_apm/error/log'
-require 'elastic_apm/error/context'
 
 module ElasticAPM
   # @api private
   class Error
     def initialize(culprit: nil)
+      @id = SecureRandom.uuid
       @culprit = culprit
 
       @timestamp = Util.micros
       @context = Context.new
+
+      @transaction_id = nil
     end
 
-    attr_accessor :culprit, :exception, :log
-    attr_reader :timestamp, :context
+    attr_accessor :id, :culprit, :exception, :log, :transaction_id, :context
+    attr_reader :timestamp
   end
 end

data/lib/elastic_apm/error_builder.rb

@@ -9,17 +9,15 @@ module ElasticAPM
 
     attr_reader :config
 
-    def build_exception(exception, rack_env: nil, handled: true)
+    def build_exception(exception, 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
+      add_stacktrace error, :exception, exception.backtrace
+      add_transaction_id error
 
-      if rack_env
-        error.context.request = Error::Context::Request.from_rack_env rack_env
+      if (transaction = ElasticAPM.current_transaction)
+        error.context = transaction.context.dup
       end
 
       error
@@ -29,12 +27,30 @@ module ElasticAPM
       error = Error.new
       error.log = Error::Log.new(message, **attrs)
 
-      if (stacktrace = Stacktrace.build(config, backtrace))
+      add_stacktrace error, :log, backtrace
+      add_transaction_id error
+
+      error
+    end
+
+    private
+
+    def add_stacktrace(error, kind, backtrace)
+      return unless (stacktrace = Stacktrace.build(config, backtrace))
+
+      case kind
+      when :exception
+        error.exception.stacktrace = stacktrace
+      when :log
         error.log.stacktrace = stacktrace
-        error.culprit = stacktrace.frames.last.function
       end
 
-      error
+      error.culprit = stacktrace.frames.last.function
+    end
+
+    def add_transaction_id(error)
+      return unless (transaction = ElasticAPM.current_transaction)
+      error.transaction_id = transaction.id
     end
   end
 end