atatus 1.0.0

data/lib/atatus/normalizers/action_controller.rb

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

data/lib/atatus/normalizers/action_mailer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Normalizers
+    module ActionMailer
+      # @api private
+      class ProcessActionNormalizer < Normalizer
+        register 'process.action_mailer'
+
+        TYPE = 'app'
+        SUBTYPE = 'mailer'
+        ACTION = 'action'
+
+        def normalize(_transaction, _name, payload)
+          [endpoint(payload), TYPE, SUBTYPE, ACTION, nil]
+        end
+
+        private
+
+        def endpoint(payload)
+          "#{payload[:mailer]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/atatus/normalizers/action_view.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Normalizers
+    module ActionView
+      # @api private
+      class RenderNormalizer < Normalizer
+        private
+
+        def normalize_render(payload, type, subtype, action)
+          [path_for(payload[:identifier]), type, subtype, action, 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'
+        SUBTYPE = 'view'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE, SUBTYPE, nil)
+        end
+      end
+
+      # @api private
+      class RenderPartialNormalizer < RenderNormalizer
+        register 'render_partial.action_view'
+        TYPE = 'template'
+        SUBTYPE = 'view'
+        ACTION = 'partial'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE, SUBTYPE, ACTION)
+        end
+      end
+
+      # @api private
+      class RenderCollectionNormalizer < RenderNormalizer
+        register 'render_collection.action_view'
+        TYPE = 'template'
+        SUBTYPE = 'view'
+        ACTION = 'collection'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE, SUBTYPE, ACTION)
+        end
+      end
+    end
+  end
+end

data/lib/atatus/normalizers/active_record.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'atatus/sql_summarizer'
+
+module Atatus
+  module Normalizers
+    module ActiveRecord
+      # @api private
+      class SqlNormalizer < Normalizer
+        register 'sql.active_record'
+
+        TYPE = 'db'
+        ACTION = 'sql'
+
+        def initialize(*args)
+          super
+
+          @subtype = lookup_adapter || 'unknown'
+          @summarizer = SqlSummarizer.new
+        end
+
+        def normalize(_transaction, _name, payload)
+          return :skip if %w[SCHEMA CACHE].include?(payload[:name])
+
+          name = summarize(payload[:sql]) || payload[:name]
+          context =
+            Span::Context.new(db: { statement: payload[:sql], type: 'sql' })
+          [name, TYPE, @subtype, ACTION, 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/atatus/opentracing.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require 'atatus'
+require 'opentracing'
+
+module Atatus
+  module OpenTracing
+    # @api private
+    class Span
+      def initialize(atatus_span, span_context)
+        @atatus_span = atatus_span
+        @span_context = span_context
+      end
+
+      attr_reader :atatus_span
+
+      def operation_name=(name)
+        atatus_span.name = name
+      end
+
+      def context
+        @span_context
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def set_label(key, val)
+        if atatus_span.is_a?(Transaction)
+          case key.to_s
+          when 'type'
+            atatus_span.type = val
+          when 'result'
+            atatus_span.result = val
+          when /user\.(\w+)/
+            set_user_value($1, val)
+          else
+            atatus_span.context.labels[key] = val
+          end
+        else
+          atatus_span.context.labels[key] = val
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def set_baggage_item(_key, _value)
+        Atatus.agent.config.logger.warn(
+          'Baggage is not supported by Atatus'
+        )
+      end
+
+      def get_baggage_item(_key)
+        Atatus.agent.config.logger.warn(
+          'Baggage is not supported by Atatus'
+        )
+
+        nil
+      end
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def log_kv(timestamp: nil, **fields)
+        if (exception = fields[:'error.object'])
+          Atatus.report exception
+        elsif (message = fields[:message])
+          Atatus.report_message message
+        end
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      # rubocop:disable Metrics/MethodLength
+      def finish(clock_end: Util.monotonic_micros, end_time: nil)
+        return unless (instrumenter = Atatus.agent&.instrumenter)
+
+        if end_time
+          warn '[Atatus] DEPRECATED: Setting a custom end time as a ' \
+            '`Time` is deprecated. Use `clock_end:` and monotonic time instead.'
+          clock_end = end_time
+        end
+
+        atatus_span.done clock_end: clock_end
+
+        case atatus_span
+        when Atatus::Transaction
+          instrumenter.current_transaction = nil
+        when Atatus::Span
+          instrumenter.current_spans.delete(atatus_span)
+        end
+
+        instrumenter.enqueue.call atatus_span
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def set_user_value(key, value)
+        return unless atatus_span.is_a?(Transaction)
+
+        setter = :"#{key}="
+        return unless atatus_span.context.user.respond_to?(setter)
+        atatus_span.context.user.send(setter, value)
+      end
+    end
+
+    # @api private
+    class SpanContext
+      def initialize(trace_context:, baggage: nil)
+        if baggage
+          Atatus.agent.config.logger.warn(
+            'Baggage is not supported by Atatus'
+          )
+        end
+
+        @trace_context = trace_context
+      end
+
+      attr_accessor :trace_context
+
+      def self.from_trace_context(trace_context)
+        new(trace_context: trace_context)
+      end
+    end
+
+    # @api private
+    class Scope
+      def initialize(span, scope_stack, finish_on_close:)
+        @span = span
+        @scope_stack = scope_stack
+        @finish_on_close = finish_on_close
+      end
+
+      attr_reader :span
+
+      def atatus_span
+        span.atatus_span
+      end
+
+      def close
+        @span.finish if @finish_on_close
+        @scope_stack.pop
+      end
+    end
+
+    # @api private
+    class ScopeStack
+      KEY = :__atatus_ot_scope_stack
+
+      def push(scope)
+        scopes << scope
+      end
+
+      def pop
+        scopes.pop
+      end
+
+      def last
+        scopes.last
+      end
+
+      private
+
+      def scopes
+        Thread.current[KEY] ||= []
+      end
+    end
+
+    # @api private
+    class ScopeManager
+      def initialize
+        @scope_stack = ScopeStack.new
+      end
+
+      def activate(span, finish_on_close: true)
+        return active if active && active.span == span
+
+        scope = Scope.new(span, @scope_stack, finish_on_close: finish_on_close)
+        @scope_stack.push scope
+        scope
+      end
+
+      def active
+        @scope_stack.last
+      end
+    end
+
+    # rubocop:disable Metrics/ClassLength
+    # A custom tracer to use the OpenTracing API with Atatus
+    class Tracer
+      def initialize
+        @scope_manager = ScopeManager.new
+      end
+
+      attr_reader :scope_manager
+
+      def active_span
+        scope_manager.active&.span
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def start_active_span(
+        operation_name,
+        child_of: nil,
+        references: nil,
+        start_time: Time.now,
+        labels: {},
+        ignore_active_scope: false,
+        finish_on_close: true,
+        **
+      )
+        span = start_span(
+          operation_name,
+          child_of: child_of,
+          references: references,
+          start_time: start_time,
+          labels: labels,
+          ignore_active_scope: ignore_active_scope
+        )
+        scope = scope_manager.activate(span, finish_on_close: finish_on_close)
+
+        if block_given?
+          begin
+            yield scope
+          ensure
+            scope.close
+          end
+        end
+
+        scope
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      # rubocop:disable Metrics/AbcSize
+      def start_span(
+        operation_name,
+        child_of: nil,
+        references: nil,
+        start_time: Time.now,
+        labels: {},
+        ignore_active_scope: false,
+        **
+      )
+        span_context = prepare_span_context(
+          child_of: child_of,
+          references: references,
+          ignore_active_scope: ignore_active_scope
+        )
+
+        if span_context
+          trace_context =
+            span_context &&
+            span_context.respond_to?(:trace_context) &&
+            span_context.trace_context
+        end
+
+        atatus_span =
+          if Atatus.current_transaction
+            Atatus.start_span(
+              operation_name,
+              trace_context: trace_context
+            )
+          else
+            Atatus.start_transaction(
+              operation_name,
+              trace_context: trace_context
+            )
+          end
+
+        # if no Atatus APM agent is running or transaction not sampled
+        unless atatus_span
+          return ::OpenTracing::Span::NOOP_INSTANCE
+        end
+
+        span_context ||=
+          SpanContext.from_trace_context(atatus_span.trace_context)
+
+        labels.each do |key, value|
+          atatus_span.context.labels[key] = value
+        end
+
+        atatus_span.start Util.micros(start_time)
+
+        Span.new(atatus_span, span_context)
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+
+      def inject(span_context, format, carrier)
+        case format
+        when ::OpenTracing::FORMAT_RACK
+          carrier['atatus-traceparent'] = span_context.to_header
+        else
+          warn 'Only injection via HTTP headers and Rack is available'
+        end
+      end
+
+      def extract(format, carrier)
+        case format
+        when ::OpenTracing::FORMAT_RACK
+          Atatus::TraceContext
+            .parse(carrier['HTTP_ATATUS_APM_TRACEPARENT'])
+        else
+          warn 'Only extraction from HTTP headers via Rack is available'
+          nil
+        end
+      rescue Atatus::TraceContext::InvalidTraceparentHeader
+        nil
+      end
+
+      private
+
+      def prepare_span_context(
+        child_of:,
+        references:,
+        ignore_active_scope:
+      )
+        context_from_child_of(child_of) ||
+          context_from_references(references) ||
+          context_from_active_scope(ignore_active_scope)
+      end
+
+      def context_from_child_of(child_of)
+        return unless child_of
+        child_of.respond_to?(:context) ? child_of.context : child_of
+      end
+
+      def context_from_references(references)
+        return if !references || references.none?
+
+        child_of = references.find do |reference|
+          reference.type == ::OpenTracing::Reference::CHILD_OF
+        end
+
+        (child_of || references.first).context
+      end
+
+      def context_from_active_scope(ignore_active_scope)
+        if ignore_active_scope
+          Atatus.agent&.config&.logger&.warn(
+            'ignore_active_scope might lead to unexpeced results'
+          )
+          return
+        end
+        @scope_manager.active&.span&.context
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end