oneapm_rpm 1.1.0

data/lib/one_apm/transaction/class_methods.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+
+    class << self
+
+      def start_new_transaction(state, category, options)
+        txn = Transaction.new(category, options)
+        state.reset(txn)
+        txn.start(state)
+        txn
+      end
+
+      def start(state, category, options)
+        category ||= :controller
+        txn = state.current_transaction
+
+        if txn
+          txn.create_nested_frame(state, category, options)
+        else
+          txn = start_new_transaction(state, category, options)
+        end
+
+        txn
+      rescue => e
+        OneApm::Agent.logger.error("Exception during Transaction.start", e)
+        nil
+      end
+
+      def stop(state, end_time=Time.now)
+        txn = state.current_transaction
+
+        if txn.nil?
+          OneApm::Agent.logger.error(Transaction::FAILED_TO_STOP_MESSAGE)
+          return
+        end
+
+        nested_frame = txn.frame_stack.pop
+
+        if txn.frame_stack.empty?
+          txn.stop(state, end_time, nested_frame)
+          state.reset
+        else
+          nested_name = nested_transaction_name(nested_frame.name)
+
+          if nested_name.start_with?(Transaction::MIDDLEWARE_PREFIX)
+            summary_metrics = Transaction::MIDDLEWARE_SUMMARY_METRICS
+          else
+            summary_metrics = Transaction::EMPTY_SUMMARY_METRICS
+          end
+
+          OneApm::Support::MethodTracer::Helpers.trace_execution_scoped_footer(
+            state,
+            nested_frame.start_time.to_f,
+            nested_name,
+            summary_metrics,
+            nested_frame,
+            Transaction::NESTED_TRACE_STOP_OPTIONS,
+            end_time.to_f)
+        end
+
+        :transaction_stopped
+      rescue => e
+        state.reset
+        OneApm::Agent.logger.error("Exception during Transaction.stop", e)
+        nil
+      end
+
+      def wrap(state, name, category, options = {})
+        Transaction.start(state, category, options.merge(:transaction_name => name))
+        begin
+          yield
+        rescue => e
+          Transaction.notice_error(e)
+          raise e
+        ensure
+          Transaction.stop(state)
+        end
+      end
+
+      def nested_transaction_name(name)
+        if name.start_with?(Transaction::CONTROLLER_PREFIX) || name.start_with?(Transaction::OTHER_TRANSACTION_PREFIX)
+          "#{Transaction::SUBTRANSACTION_PREFIX}#{name}"
+        else
+          name
+        end
+      end
+
+      #
+      # * duration: response time
+      # * failed: the request is failed or not
+      # * apdex_s: satisfy
+      # * apdex_t: tolerate
+      # * apdex_f: frustrate
+      #
+      def apdex_bucket(duration, failed, apdex_t)
+        case
+        when failed
+          :apdex_f  # frustrate if request failed
+        when duration <= apdex_t
+          :apdex_s  # satisfy if duration < tolerate
+        when duration <= 4 * apdex_t
+          :apdex_t  # tolerate if duration < 4 * tolerate
+        else
+          :apdex_f  # otherwise frustrate
+        end
+      end
+
+      # Make a safe attempt to get the URI, without the host and query string.
+      def uri_from_request(req)
+        approximate_uri = case
+                          when req.respond_to?(:fullpath   ) then req.fullpath
+                          when req.respond_to?(:path       ) then req.path
+                          when req.respond_to?(:request_uri) then req.request_uri
+                          when req.respond_to?(:uri        ) then req.uri
+                          when req.respond_to?(:url        ) then req.url
+                          end
+        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
+      end
+
+      # Make a safe attempt to get the referer from a request object, generally successful when
+      # it's a Rack request.
+      def referer_from_request(req)
+        if req && req.respond_to?(:referer)
+          req.referer.to_s.split('?').first
+        end
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/instance_helpers.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+    module InstanceHelpers
+
+      def agent
+        OneApm::Agent.instance
+      end
+
+      def transaction_sampler
+        agent.transaction_sampler
+      end
+
+      def sql_sampler
+        agent.sql_sampler
+      end
+
+      def recording_web_transaction?
+        web_category?(@category)
+      end
+
+      def web_category?(category)
+        Transaction::WEB_TRANSACTION_CATEGORIES.include?(category)
+      end
+
+      def similar_category?(category)
+        web_category?(@category) == web_category?(category)
+      end
+
+      def queue_time
+        @apdex_start ? @start_time - @apdex_start : 0
+      end
+
+      def had_error?
+        !notable_exceptions.empty?
+      end
+
+      def notable_exceptions
+        @exceptions.keys.select do |exception|
+          !agent.error_collector.error_is_ignored?(exception)
+        end
+      end
+
+      def add_custom_parameters(p)
+        if OneApm::Agent.config[:high_security]
+          OneApm::Agent.logger.debug("Unable to add custom attributes #{p.keys.inspect} while in high security mode.")
+          return
+        end
+
+        custom_parameters.merge!(p)
+      end
+
+      # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
+      def uri
+        @uri ||= self.class.uri_from_request(@request) unless @request.nil?
+      end
+
+      # For the current web transaction, return the full referer, minus the host string, or nil.
+      def referer
+        @referer ||= self.class.referer_from_request(@request)
+      end
+
+      def custom_parameters
+        @custom_parameters ||= {}
+      end
+
+      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+      GUID_LENGTH = 16
+
+      # generate a random 64 bit uuid
+      def generate_guid
+        guid = ''
+        GUID_LENGTH.times do |a|
+          guid << HEX_DIGITS[rand(16)]
+        end
+        guid
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/metric_constants.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+
+    SUBTRANSACTION_PREFIX        = 'Nested/'.freeze
+    CONTROLLER_PREFIX            = 'Controller/'.freeze
+    MIDDLEWARE_PREFIX            = 'Middleware/Rack/'.freeze
+    TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
+    RACK_PREFIX                  = 'Controller/Rack/'.freeze
+    SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
+    GRAPE_PREFIX                 = 'Controller/Grape/'.freeze
+    OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
+
+    CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
+
+    WEB_SUMMARY_METRIC   = 'HttpDispatcher'.freeze
+    OTHER_SUMMARY_METRIC = 'OtherTransaction/all'.freeze
+
+    APDEX_S = 'S'.freeze
+    APDEX_T = 'T'.freeze
+    APDEX_F = 'F'.freeze
+    APDEX_METRIC = 'Apdex'.freeze
+
+    QUEUE_TIME_METRIC = 'WebFrontend/QueueTime'.freeze
+
+    NESTED_TRACE_STOP_OPTIONS    = { :metric => true }.freeze
+    WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :grape, :middleware].freeze
+    TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
+
+    MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
+    EMPTY_SUMMARY_METRICS        = [].freeze
+
+    TRACE_OPTIONS_SCOPED         = {:metric => true, :scoped_metric => true}.freeze
+    TRACE_OPTIONS_UNSCOPED       = {:metric => true, :scoped_metric => false}.freeze
+
+    UNKNOWN_METRIC = '(unknown)'.freeze
+
+    FAILED_TO_STOP_MESSAGE = "Failed during Transaction.stop because there is no current transaction"
+
+  end
+end

data/lib/one_apm/transaction/sample_buffer/force_persist_sample_buffer.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'one_apm/transaction/sample_buffer/transaction_sample_buffer'
+
+module OneApm
+  class Transaction
+    class ForcePersistSampleBuffer < TransactionSampleBuffer
+
+      CAPACITY = 10
+
+      def capacity
+        CAPACITY
+      end
+
+      def allow_sample?(sample)
+        sample.force_persist
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/sample_buffer/slowest_sample_buffer.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'one_apm/transaction/sample_buffer/transaction_sample_buffer'
+
+module OneApm
+  class Transaction
+    class SlowestSampleBuffer < TransactionSampleBuffer
+
+      CAPACITY = 1
+
+      def capacity
+        CAPACITY
+      end
+
+      def allow_sample?(sample)
+        sample.threshold && sample.duration >= sample.threshold
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/sample_buffer/synthetics_sample_buffer.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'one_apm/transaction/sample_buffer/transaction_sample_buffer'
+
+module OneApm
+  class Transaction
+    class SyntheticsSampleBuffer < TransactionSampleBuffer
+      def capacity
+        OneApm::Agent.config[:'synthetics.traces_limit']
+      end
+
+      def allow_sample?(sample)
+        sample.synthetics_resource_id != nil
+      end
+
+      def truncate_samples
+        @samples.slice!(max_capacity..-1)
+      end
+    end
+  end
+end

data/lib/one_apm/transaction/sample_buffer/transaction_sample_buffer.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+    class TransactionSampleBuffer
+      attr_reader :samples
+
+      SINGLE_BUFFER_MAX = 20
+      NO_SAMPLES = [].freeze
+
+      def initialize
+        @samples = []
+      end
+
+      def enabled?
+        true
+      end
+
+      def reset!
+        @samples = []
+      end
+
+      def harvest_samples
+        @samples
+      ensure
+        reset!
+      end
+
+      def allow_sample?(sample)
+        true
+      end
+
+      def store(sample)
+        return unless enabled?
+        if allow_sample?(sample)
+          add_sample(sample)
+          truncate_samples_if_needed
+        end
+      end
+
+      def store_previous(previous_samples)
+        return unless enabled?
+        previous_samples.each do |sample|
+          add_sample(sample) if allow_sample?(sample)
+        end
+        truncate_samples_if_needed
+      end
+
+      def truncate_samples_if_needed
+        truncate_samples if full?
+      end
+
+      def full?
+        @samples.length >= max_capacity
+      end
+
+      # Capacity is the desired number of samples a buffer will hold. This
+      # can be user dictated via config if a feature wants.
+      #
+      # This value will be forcibly capped by the max_capacity
+      def capacity
+        raise NotImplementedError.new("TransactionSampleBuffer subclasses must provide a capacity override")
+      end
+
+      # Apply hard upper limit to the capacity to prevent users from
+      # consuming too much memory buffering TT's.
+      #
+      # A typical buffer should NOT override this method (although we do for
+      # odd things like dev-mode)
+      def max_capacity
+        capacity > SINGLE_BUFFER_MAX ? SINGLE_BUFFER_MAX : capacity
+      end
+
+      # Our default truncation strategy is to keep max_capacity
+      # worth of the longest samples. Override this method for alternate
+      # behavior.
+      #
+      # This doesn't use the more convenient #last and #sort_by to avoid
+      # additional array allocations (and abundant alliteration)
+      def truncate_samples
+        @samples.sort!{|a,b| a.duration <=> b.duration}
+        @samples.slice!(0..-(max_capacity + 1))
+      end
+
+      # When pushing a scope different sample buffers potentially want to
+      # know about what's happening to annotate the incoming segments
+      def visit_segment(*)
+        # no-op
+      end
+
+      private
+
+      # If a buffer needs to modify an added sample, override this method.
+      # Bounds checking, allowing samples and truncation belongs elsewhere.
+      def add_sample(sample)
+        @samples << sample
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/sample_buffer/xray_sample_buffer.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'one_apm/transaction/sample_buffer/transaction_sample_buffer'
+
+module OneApm
+  class Transaction
+    class XraySampleBuffer < TransactionSampleBuffer
+
+      attr_writer :xray_session_collection
+
+      def initialize
+        super
+
+        # Memoize the config setting since this happens per request
+        @enabled = OneApm::Agent.config[:'xray_session.allow_traces']
+        OneApm::Agent.config.register_callback(:'xray_session.allow_traces') do |new_value|
+          @enabled = new_value
+        end
+
+        @capacity = OneApm::Agent.config[:'xray_session.max_samples']
+        OneApm::Agent.config.register_callback(:'xray_session.max_samples') do |new_value|
+          @capacity = new_value
+        end
+      end
+
+      def xray_session_collection
+        @xray_session_collection ||= OneApm::Agent.instance.agent_command_router.xray_session_collection
+      end
+
+      def capacity
+        @capacity
+      end
+
+      def truncate_samples
+        # First in wins, so stop on allow_sample? instead of truncating
+      end
+
+      def allow_sample?(sample)
+        !full? && !lookup_session_id(sample).nil?
+      end
+
+      def enabled?
+        @enabled
+      end
+
+
+      private
+
+      def add_sample(sample)
+        super(sample)
+        sample.xray_session_id = lookup_session_id(sample)
+      end
+
+      def lookup_session_id(sample)
+        xray_session_collection.session_id_for_transaction_name(sample.transaction_name)
+      end
+
+    end
+  end
+end