atatus 1.0.0

data/lib/atatus/rails.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'atatus/subscriber'
+
+module Atatus
+  # Module for explicitly starting the Atatus agent and hooking into Rails.
+  # It is recommended to use the Railtie instead.
+  module Rails
+    extend self
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # Start the Atatus agent and hook into Rails.
+    # Note that the agent won't be started if the Rails console is being used.
+    #
+    # @param config [Config, Hash] An instance of Config or a Hash config.
+    # @return [true, nil] true if the agent was started, nil otherwise.
+    def start(config)
+      config = Config.new(config) unless config.is_a?(Config)
+      if (reason = should_skip?(config))
+        unless config.disable_start_message?
+          config.logger.info "Skipping because: #{reason}. " \
+            "Start manually with `Atatus.start'"
+        end
+        return
+      end
+
+      Atatus.start(config).tap do |agent|
+        attach_subscriber(agent)
+      end
+
+      if Atatus.running? &&
+         !Atatus.agent.config.disabled_instrumentations.include?(
+           'action_dispatch'
+         )
+        require 'atatus/spies/action_dispatch'
+      end
+      Atatus.running?
+    rescue StandardError => e
+      config.logger.error format('Failed to start: %s', e.message)
+      config.logger.debug "Backtrace:\n" + e.backtrace.join("\n")
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    private
+
+    def should_skip?(_config)
+      if ::Rails.const_defined? 'Rails::Console'
+        return 'Rails console'
+      end
+
+      nil
+    end
+
+    def attach_subscriber(agent)
+      return unless agent
+
+      agent.instrumenter.subscriber = Atatus::Subscriber.new(agent)
+    end
+  end
+end

data/lib/atatus/railtie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'atatus/rails'
+
+module Atatus
+  # @api private
+  class Railtie < ::Rails::Railtie
+    config.atatus = ActiveSupport::OrderedOptions.new
+
+    Config.schema.each do |key, args|
+      next unless args.length > 1
+      config.atatus[key] = args.last[:default]
+    end
+
+    initializer 'atatus.initialize' do |app|
+      config = Config.new(app.config.atatus).tap do |c|
+        c.app = app
+
+        # Prepend Rails.root to log_path if present
+        if c.log_path && !c.log_path.start_with?('/')
+          c.log_path = ::Rails.root.join(c.log_path)
+        end
+      end
+
+      if Rails.start(config)
+        app.middleware.insert 0, Middleware
+      end
+    end
+  end
+end

data/lib/atatus/span.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'forwardable'
+
+require 'atatus/span/context'
+
+module Atatus
+  # @api private
+  class Span
+    extend Forwardable
+
+    def_delegators :@trace_context, :trace_id, :parent_id, :id
+
+    DEFAULT_TYPE = 'custom'
+
+    # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+    def initialize(
+      name:,
+      transaction_id:,
+      trace_context:,
+      type: nil,
+      subtype: nil,
+      action: nil,
+      context: nil,
+      stacktrace_builder: nil
+    )
+      @name = name
+
+      if subtype.nil? && type&.include?('.')
+        @type, @subtype, @action = type.split('.')
+      else
+        @type = type || DEFAULT_TYPE
+        @subtype = subtype
+        @action = action
+      end
+
+      @transaction_id = transaction_id
+      @trace_context = trace_context
+
+      @context = context || Span::Context.new
+      @stacktrace_builder = stacktrace_builder
+    end
+    # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
+
+    attr_accessor(
+      :action,
+      :name,
+      :original_backtrace,
+      :subtype,
+      :trace_context,
+      :type
+    )
+    attr_reader(
+      :context,
+      :duration,
+      :stacktrace,
+      :timestamp,
+      :transaction_id
+    )
+
+    # life cycle
+
+    def start(clock_start = Util.monotonic_micros)
+      @timestamp = Util.micros
+      @clock_start = clock_start
+      self
+    end
+
+    def stop(clock_end = Util.monotonic_micros)
+      @duration ||= (clock_end - @clock_start)
+      self
+    end
+
+    def done(clock_end: Util.monotonic_micros)
+      stop clock_end
+
+      build_stacktrace! if should_build_stacktrace?
+      self.original_backtrace = nil # release original
+
+      self
+    end
+
+    def stopped?
+      !!duration
+    end
+
+    def started?
+      !!timestamp
+    end
+
+    def running?
+      started? && !stopped?
+    end
+
+    # relations
+
+    def inspect
+      "<Atatus::Span id:#{id}" \
+        " name:#{name.inspect}" \
+        " type:#{type.inspect}" \
+        '>'
+    end
+
+    private
+
+    def build_stacktrace!
+      @stacktrace = @stacktrace_builder.build(original_backtrace, type: :span)
+    end
+
+    def should_build_stacktrace?
+      @stacktrace_builder && original_backtrace && long_enough_for_stacktrace?
+    end
+
+    def long_enough_for_stacktrace?
+      min_duration =
+        @stacktrace_builder.config.span_frames_min_duration_us
+
+      return true if min_duration < 0
+      return false if min_duration == 0
+
+      duration >= min_duration
+    end
+  end
+end

data/lib/atatus/span/context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Span
+    # @api private
+    class Context
+      def initialize(db: nil, http: nil, labels: {})
+        @sync = true
+        @db = db && Db.new(db)
+        @http = http && Http.new(http)
+        @labels = labels
+      end
+
+      attr_accessor :sync, :db, :http, :labels
+
+      # @api private
+      class Db
+        def initialize(instance: nil, statement: nil, type: nil, user: nil)
+          @instance = instance
+          @statement = statement
+          @type = type
+          @user = user
+        end
+
+        attr_accessor :instance, :statement, :type, :user
+      end
+
+      # @api private
+      class Http
+        def initialize(url: nil, status_code: nil, method: nil)
+          @url = url
+          @status_code = status_code
+          @method = method
+        end
+
+        attr_accessor :url, :status_code, :method
+      end
+    end
+  end
+end

data/lib/atatus/span_helpers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module SpanHelpers
+    # @api private
+    module ClassMethods
+      def span_class_method(method, name = nil, type = nil)
+        __span_method_on(singleton_class, method, name, type)
+      end
+
+      def span_method(method, name = nil, type = nil)
+        __span_method_on(self, method, name, type)
+      end
+
+      private
+
+      def __span_method_on(klass, method, name = nil, type = nil)
+        name ||= method.to_s
+        type ||= Span::DEFAULT_TYPE
+
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias :"__without_apm_#{method}" :"#{method}"
+
+          def #{method}(*args, &block)
+            unless Atatus.current_transaction
+              return __without_apm_#{method}(*args, &block)
+            end
+
+            Atatus.with_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

data/lib/atatus/spies.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'atatus/util/inflector'
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class Registration
+      extend Forwardable
+
+      def initialize(const_name, require_paths, spy)
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @spy = spy
+      end
+
+      attr_reader :const_name, :require_paths
+
+      def_delegator :@spy, :install
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.register(*args)
+      registration = Registration.new(*args)
+
+      if safe_defined?(registration.const_name)
+        registration.install
+        installed[registration.const_name] = registration
+      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.hook_into(name)
+      return unless (registration = require_hooks[name])
+      return unless safe_defined?(registration.const_name)
+
+      installed[registration.const_name] = registration
+      registration.install
+
+      registration.require_paths.each do |path|
+        require_hooks.delete path
+      end
+    end
+
+    def self.safe_defined?(const_name)
+      Util::Inflector.safe_constantize(const_name)
+    end
+  end
+end
+
+# @api private
+module Kernel
+  private
+
+  alias require_without_apm require
+
+  def require(path)
+    res = require_without_apm(path)
+
+    begin
+      Atatus::Spies.hook_into(path)
+    rescue ::Exception => e
+      puts "Failed hooking into '#{path}'. Please report this at " \
+        'success@atatus.com'
+      puts e.backtrace.join("\n")
+    end
+
+    res
+  end
+end

data/lib/atatus/spies/action_dispatch.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class ActionDispatchSpy
+      def install
+        ::ActionDispatch::ShowExceptions.class_eval do
+          alias render_exception_without_apm render_exception
+
+          def render_exception(env, exception)
+            context = Atatus.build_context(rack_env: env, for_type: :error)
+            Atatus.report(exception, context: context, handled: false)
+
+            render_exception_without_apm env, exception
+          end
+        end
+      end
+    end
+
+    register(
+      'ActionDispatch::ShowExceptions',
+      'action_dispatch/show_exception',
+      ActionDispatchSpy.new
+    )
+  end
+end

data/lib/atatus/spies/delayed_job.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class DelayedJobSpy
+      CLASS_SEPARATOR = '.'
+      METHOD_SEPARATOR = '#'
+      TYPE = 'Delayed::Job'
+
+      def install
+        ::Delayed::Backend::Base.class_eval do
+          alias invoke_job_without_apm invoke_job
+
+          def invoke_job(*args, &block)
+            ::Atatus::Spies::DelayedJobSpy
+              .invoke_job(self, *args, &block)
+          end
+        end
+      end
+
+      def self.invoke_job(job, *args, &block)
+        job_name = name_from_payload(job.payload_object)
+        transaction = Atatus.start_transaction(job_name, TYPE)
+        job.invoke_job_without_apm(*args, &block)
+        transaction.done 'success'
+      rescue ::Exception => e
+        Atatus.report(e, handled: false)
+        transaction.done 'error'
+        raise
+      ensure
+        Atatus.end_transaction
+      end
+
+      def self.name_from_payload(payload_object)
+        if payload_object.is_a?(::Delayed::PerformableMethod)
+          performable_method_name(payload_object)
+        else
+          payload_object.class.name
+        end
+      end
+
+      def self.performable_method_name(payload_object)
+        class_name = object_name(payload_object)
+        separator = name_separator(payload_object)
+        method_name = payload_object.method_name
+        "#{class_name}#{separator}#{method_name}"
+      end
+
+      def self.object_name(payload_object)
+        object = payload_object.object
+        klass = object.is_a?(Class) ? object : object.class
+        klass.name
+      end
+
+      def self.name_separator(payload_object)
+        payload_object.object.is_a?(Class) ? CLASS_SEPARATOR : METHOD_SEPARATOR
+      end
+    end
+
+    register(
+      'Delayed::Backend::Base',
+      'delayed/backend/base',
+      DelayedJobSpy.new
+    )
+  end
+end