atatus 1.0.0

data/lib/atatus/deprecations.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Deprecations
+    def deprecate(name, replacement = nil)
+      alias_name = "#{name.to_s.chomp('=')}__deprecated_"
+      alias_name += '=' if name.to_s.end_with?('=')
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        alias :"#{alias_name}" :"#{name}"
+
+        def #{name}(*args, &block)
+          warn "[Atatus] [DEPRECATED] `#{name}' is being removed. " \
+               "#{replacement && "See `#{replacement}'."}" \
+               "\nCalled from \#{caller.first}"
+          send("#{alias_name}", *args, &block)
+        end
+      RUBY
+    end
+  end
+end

data/lib/atatus/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'atatus/stacktrace'
+require 'atatus/context'
+require 'atatus/error/exception'
+require 'atatus/error/log'
+
+module Atatus
+  # @api private
+  class Error
+    def initialize(culprit: nil, context: nil)
+      @id = SecureRandom.hex(16)
+      @culprit = culprit
+      @timestamp = Util.micros
+      @context = context
+    end
+
+    attr_accessor :id, :culprit, :exception, :log, :transaction_id,
+      :transaction, :context, :parent_id, :trace_id
+    attr_reader :timestamp
+  end
+end

data/lib/atatus/error/exception.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Error
+    # @api private
+    class Exception
+      MOD_SPLIT = '::'
+
+      def initialize(attrs = nil)
+        return unless attrs
+
+        attrs.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      def self.from_exception(exception, **attrs)
+        new({
+          message: exception.message.to_s,
+          type: exception.class.to_s,
+          module: format_module(exception),
+          cause: exception.cause && Exception.from_exception(exception.cause)
+        }.merge(attrs))
+      end
+
+      attr_accessor(
+        :attributes,
+        :code,
+        :handled,
+        :message,
+        :module,
+        :stacktrace,
+        :type,
+        :cause
+      )
+
+      class << self
+        private
+
+        def format_module(exception)
+          exception.class.to_s.split(MOD_SPLIT)[0...-1].join(MOD_SPLIT)
+        end
+      end
+    end
+  end
+end

data/lib/atatus/error/log.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Atatus
+  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/atatus/error_builder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class ErrorBuilder
+    def initialize(agent)
+      @agent = agent
+    end
+
+    def build_exception(exception, context: nil, handled: true)
+      error = Error.new context: context || Context.new
+      error.exception =
+        Error::Exception.from_exception(exception, handled: handled)
+
+      Util.reverse_merge!(error.context.labels, @agent.config.default_labels)
+
+      if exception.backtrace
+        add_stacktrace error, :exception, exception.backtrace
+      end
+
+      add_current_transaction_fields error, Atatus.current_transaction
+
+      error
+    end
+
+    def build_log(message, context: nil, backtrace: nil, **attrs)
+      error = Error.new context: context || Context.new
+      error.log = Error::Log.new(message, **attrs)
+
+      if backtrace
+        add_stacktrace error, :log, backtrace
+      end
+
+      add_current_transaction_fields error, Atatus.current_transaction
+
+      error
+    end
+
+    private
+
+    def add_stacktrace(error, kind, backtrace)
+      stacktrace =
+        @agent.stacktrace_builder.build(backtrace, type: :error)
+      return unless stacktrace
+
+      case kind
+      when :exception
+        error.exception.stacktrace = stacktrace
+      when :log
+        error.log.stacktrace = stacktrace
+      end
+
+      error.culprit = stacktrace.frames.first&.function
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def add_current_transaction_fields(error, transaction)
+      return unless transaction
+
+      error.transaction_id = transaction.id
+      error.transaction = {
+        sampled: transaction.sampled?,
+        type: transaction.type
+      }
+      error.transaction[:name] = transaction.name unless transaction.name.nil?
+      error.trace_id = transaction.trace_id
+      error.parent_id = Atatus.current_span&.id || transaction.id
+
+      return unless transaction.context
+
+      Util.reverse_merge!(error.context.labels, transaction.context.labels)
+      Util.reverse_merge!(error.context.custom, transaction.context.custom)
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+end

data/lib/atatus/instrumenter.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'atatus/trace_context'
+require 'atatus/span'
+require 'atatus/transaction'
+require 'atatus/span_helpers'
+
+module Atatus
+  # rubocop:disable Metrics/ClassLength
+  # @api private
+  class Instrumenter
+    TRANSACTION_KEY = :__atatus_instrumenter_transaction_key
+    SPAN_KEY = :__atatus_instrumenter_spans_key
+
+    include Logging
+
+    # @api private
+    class Current
+      def initialize
+        self.transaction = nil
+        self.spans = []
+      end
+
+      def transaction
+        Thread.current[TRANSACTION_KEY]
+      end
+
+      def transaction=(transaction)
+        Thread.current[TRANSACTION_KEY] = transaction
+      end
+
+      def spans
+        Thread.current[SPAN_KEY] ||= []
+      end
+
+      def spans=(spans)
+        Thread.current[SPAN_KEY] ||= []
+        Thread.current[SPAN_KEY] = spans
+      end
+    end
+
+    def initialize(config, stacktrace_builder:, &enqueue)
+      @config = config
+      @stacktrace_builder = stacktrace_builder
+      @enqueue = enqueue
+
+      @current = Current.new
+    end
+
+    attr_reader :config, :stacktrace_builder, :enqueue
+
+    def start
+      debug 'Starting instrumenter'
+    end
+
+    def stop
+      debug 'Stopping instrumenter'
+
+      self.current_transaction = nil
+      current_spans.pop until current_spans.empty?
+
+      @subscriber.unregister! if @subscriber
+    end
+
+    def subscriber=(subscriber)
+      debug 'Registering subscriber'
+      @subscriber = subscriber
+      @subscriber.register!
+    end
+
+    # transactions
+
+    def current_transaction
+      @current.transaction
+    end
+
+    def current_transaction=(transaction)
+      @current.transaction = transaction
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def start_transaction(
+      name = nil,
+      type = nil,
+      context: nil,
+      trace_context: nil
+    )
+      return nil unless config.instrument?
+
+      if (transaction = current_transaction)
+        raise ExistingTransactionError,
+          "Transactions may not be nested.\nAlready inside #{transaction}"
+      end
+
+      sampled = trace_context ? trace_context.recorded? : random_sample?
+
+      transaction =
+        Transaction.new(
+          name,
+          type,
+          context: context,
+          trace_context: trace_context,
+          sampled: sampled,
+          labels: config.default_labels
+        )
+
+      transaction.start
+
+      self.current_transaction = transaction
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def end_transaction(result = nil)
+      return nil unless (transaction = current_transaction)
+
+      self.current_transaction = nil
+
+      transaction.done result
+
+      enqueue.call transaction
+
+      transaction
+    end
+
+    # spans
+
+    def current_spans
+      @current.spans
+    end
+
+    def current_span
+      current_spans.last
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/ParameterLists
+    def start_span(
+      name,
+      type = nil,
+      subtype: nil,
+      action: nil,
+      backtrace: nil,
+      context: nil,
+      trace_context: nil
+    )
+      return unless (transaction = current_transaction)
+      return unless transaction.sampled?
+
+      transaction.inc_started_spans!
+
+      if transaction.max_spans_reached?(config)
+        transaction.inc_dropped_spans!
+        return
+      end
+
+      parent = current_span || transaction
+
+      span = Span.new(
+        name: name,
+        subtype: subtype,
+        action: action,
+        transaction_id: transaction.id,
+        trace_context: trace_context || parent.trace_context.child,
+        type: type,
+        context: context,
+        stacktrace_builder: stacktrace_builder
+      )
+
+      if backtrace && config.span_frames_min_duration?
+        span.original_backtrace = backtrace
+      end
+
+      current_spans.push span
+
+      span.start
+    end
+    # rubocop:enable Metrics/ParameterLists
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+
+    def end_span
+      return unless (span = current_spans.pop)
+
+      span.done
+
+      enqueue.call span
+
+      span
+    end
+
+    # metadata
+
+    def set_label(key, value)
+      return unless current_transaction
+
+      key = key.to_s.gsub(/[\."\*]/, '_').to_sym
+      current_transaction.context.labels[key] = value
+    end
+
+    def set_custom_context(context)
+      return unless current_transaction
+      current_transaction.context.custom.merge!(context)
+    end
+
+    def set_user(user)
+      return unless current_transaction
+      current_transaction.context.user = Context::User.infer(config, user)
+    end
+
+    def inspect
+      '<Atatus::Instrumenter ' \
+        "current_transaction=#{current_transaction.inspect}" \
+        '>'
+    end
+
+    private
+
+    def random_sample?
+      rand <= config.transaction_sample_rate
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/atatus/internal_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Atatus
+  class InternalError < StandardError; end
+  class ExistingTransactionError < InternalError; end
+end

data/lib/atatus/logging.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Atatus
+  # @api private
+  module Logging
+    PREFIX = '[Atatus] '
+
+    LEVELS = {
+      debug: Logger::DEBUG,
+      info: Logger::INFO,
+      warn: Logger::WARN,
+      error: Logger::ERROR,
+      fatal: Logger::FATAL
+    }.freeze
+
+    def debug(msg, *args, &block)
+      log(:debug, msg, *args, &block)
+    end
+
+    def info(msg, *args, &block)
+      log(:info, msg, *args, &block)
+    end
+
+    def warn(msg, *args, &block)
+      log(:warn, msg, *args, &block)
+    end
+
+    def error(msg, *args, &block)
+      log(:error, msg, *args, &block)
+    end
+
+    def fatal(msg, *args, &block)
+      log(:fatal, msg, *args, &block)
+    end
+
+    private
+
+    def log(lvl, msg, *args)
+      return unless (logger = @config&.logger)
+      return unless LEVELS[lvl] >= (@config&.log_level || 0)
+
+      formatted_msg = prepend_prefix(format(msg.to_s, *args))
+
+      return logger.send(lvl, formatted_msg) unless block_given?
+
+      logger.send(lvl, "#{formatted_msg}\n#{yield}")
+    end
+
+    def prepend_prefix(str)
+      "#{PREFIX}#{str}"
+    end
+  end
+end