oneapm_rpm 1.1.0

data/lib/one_apm/transaction/transaction_sample_builder.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require 'one_apm/support/collection_helper'
+require 'one_apm/transaction/transaction_sample'
+require 'one_apm/probe'
+require 'one_apm/transaction'
+module OneApm
+  # a builder is created with every sampled transaction, to dynamically
+  # generate the sampled data.  It is a thread-local object, and is not
+  # accessed by any other thread so no need for synchronization.
+  #
+  # @api private
+  class TransactionSampleBuilder
+
+    # Once we hit the TT segment limit, we use this class to hold our place in
+    # the tree so that we can still get accurate names and times on the
+    # segments we've already created. The placeholder segment keeps a
+    # depth counter that's incremented on each segment entry, and decremented
+    # on exit, until it reaches zero, when we throw the placeholder away.
+    # There should only ever be zero or one placeholder segment at a time.
+    #
+    # @api private
+    class PlaceholderSegment
+      attr_reader :parent_segment
+      attr_accessor :depth
+
+      def initialize(parent_segment)
+        @parent_segment = parent_segment
+        @depth = 1
+      end
+
+      # No-op - some clients expect to be able to use these to read/write
+      # params on TT segments.
+      def [](key); end
+      def []=(key, value); end
+
+      # Stubbed out in case clients try to touch params directly.
+      def params; {}; end
+      def params=; end
+    end
+
+    attr_reader :current_segment, :sample
+
+    include OneApm::CollectionHelper
+
+    def initialize(time=Time.now)
+      @sample = OneApm::TransactionSample.new(time.to_f)
+      @sample_start = time.to_f
+      @current_segment = @sample.root_segment
+    end
+
+    def sample_id
+      @sample.sample_id
+    end
+
+    def ignored?
+      @ignore
+    end
+
+    def ignore_transaction
+      @ignore = true
+    end
+
+    def segment_limit
+      Agent.config[:'transaction_tracer.limit_segments']
+    end
+
+    def trace_entry(time)
+      if @sample.count_segments < segment_limit
+        segment = @sample.create_segment(time.to_f - @sample_start)
+        @current_segment.add_called_segment(segment)
+        @current_segment = segment
+        if @sample.count_segments == segment_limit()
+          ::OneApm::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
+        end
+      else
+        if @current_segment.is_a?(PlaceholderSegment)
+          @current_segment.depth += 1
+        else
+          @current_segment = PlaceholderSegment.new(@current_segment)
+        end
+      end
+      @current_segment
+    end
+
+    def trace_exit(metric_name, time)
+      if @current_segment.is_a?(PlaceholderSegment)
+        @current_segment.depth -= 1
+        if @current_segment.depth == 0
+          @current_segment = @current_segment.parent_segment
+        end
+      else
+        @current_segment.metric_name = metric_name
+        @current_segment.end_trace(time.to_f - @sample_start)
+        @current_segment = @current_segment.parent_segment
+      end
+    end
+
+    def finish_trace(time=Time.now.to_f, custom_params={})
+      # Should never get called twice, but in a rare case that we can't
+      # reproduce in house it does.  log forensics and return gracefully
+      if @sample.finished
+        ::OneApm::Agent.logger.error "Unexpected double-finish_trace of Transaction Trace Object: \n#{@sample.to_s}"
+        return
+      end
+      @sample.root_segment.end_trace(time.to_f - @sample_start)
+      @sample.params[:custom_params] ||= {}
+      @sample.params[:custom_params].merge!(normalize_params(custom_params))
+
+      # If we ever implement saving of TTs based on the record_tt flag on the
+      # calling and called applications, we should change this flag's value.
+      @sample.force_persist = false
+      @sample.threshold = transaction_trace_threshold
+      @sample.finished = true
+      @current_segment = nil
+    end
+
+    TT_THRESHOLD_KEY = :'transaction_tracer.transaction_threshold'
+
+    def transaction_trace_threshold #THREAD_LOCAL_ACCESS
+      state = TransactionState.tl_get
+      source_class = Agent.config.source(TT_THRESHOLD_KEY).class
+      if source_class == Configuration::DefaultSource && state.current_transaction
+        state.current_transaction.apdex_t * 4
+      else
+        Agent.config[TT_THRESHOLD_KEY]
+      end
+    end
+
+    def scope_depth
+      depth = -1        # have to account for the root
+      current = @current_segment
+
+      while(current)
+        depth += 1
+        current = current.parent_segment
+      end
+
+      depth
+    end
+
+    def set_transaction_uri(uri)
+      @sample.params[:uri] ||= uri
+    end
+
+    def set_request_params(params)
+      if Agent.config[:capture_params]
+        params = normalize_params(params)
+        @sample.params[:request_params].merge!(params)
+        @sample.params[:request_params].delete :controller
+        @sample.params[:request_params].delete :action
+      end
+    end
+
+    def set_transaction_name(name)
+      @sample.transaction_name = name
+    end
+
+    def set_transaction_cpu_time(cpu_time)
+      @sample.set_custom_param(:cpu_time, cpu_time)
+    end
+
+    def sample
+      @sample
+    end
+
+  end
+end

data/lib/one_apm/transaction/transaction_state.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+require 'one_apm/support/method_tracer/traced_method_stack'
+
+module OneApm
+
+  # This is THE location to store thread local information during a transaction
+  # Need a new piece of data? Add a method here, NOT a new thread local variable.
+  class TransactionState
+    def self.tl_get
+      tl_state_for(Thread.current)
+    end
+
+    # This method should only be used by TransactionState for access to the
+    # current thread's state or to provide read-only accessors for other threads
+    #
+    # If ever exposed, this requires additional synchronization
+    def self.tl_state_for(thread)
+      state = thread[:oneapm_transaction_state]
+
+      if state.nil?
+        state = TransactionState.new
+        thread[:oneapm_transaction_state] = state
+      end
+
+      state
+    end
+
+    def self.tl_clear_for_testing
+      Thread.current[:oneapm_transaction_state] = nil
+    end
+
+    def initialize
+      @untraced = []
+      @traced_method_stack =OneApm::Support::TracedMethodStack.new
+      @current_transaction = nil
+    end
+
+    # This starts the timer for the transaction.
+    def reset(transaction=nil)
+      # We purposefully don't reset @untraced, @record_tt and @record_sql
+      # since those are managed by OneApm::Agent.disable_* calls explicitly
+      # and (more importantly) outside the scope of a transaction
+
+      @timings = nil
+      @request = nil
+      @current_transaction = transaction
+
+      @traced_method_stack.clear
+
+      @is_cross_app_caller = false
+      @client_cross_app_id = nil
+      @referring_transaction_info = nil
+
+      @transaction_sample_builder = nil
+      @sql_sampler_transaction_data = nil
+
+      @busy_entries = 0
+    end
+
+    def timings
+      @timings ||= TransactionTimings.new(transaction_queue_time, transaction_start_time, transaction_name)
+    end
+
+    # Cross app tracing
+    # Because we need values from headers before the transaction actually starts
+    attr_accessor :client_cross_app_id, :referring_transaction_info, :is_cross_app_caller
+
+    def is_cross_app_caller?
+      @is_cross_app_caller
+    end
+
+    def is_cross_app_callee?
+      referring_transaction_info != nil
+    end
+
+    def is_cross_app?
+      is_cross_app_caller? || is_cross_app_callee?
+    end
+
+    # Request data
+    attr_accessor :request
+
+    def request_guid
+      return nil unless current_transaction
+      current_transaction.guid
+    end
+
+    # Current transaction stack and sample building
+    attr_reader   :current_transaction
+    attr_accessor :transaction_sample_builder
+
+    def transaction_start_time
+      current_transaction.start_time if current_transaction
+    end
+
+    def transaction_queue_time
+      current_transaction.nil? ? 0.0 : current_transaction.queue_time
+    end
+
+    def transaction_name
+      current_transaction.nil? ? nil : current_transaction.best_name
+    end
+
+    def in_background_transaction?
+      !current_transaction.nil? && !current_transaction.recording_web_transaction?
+    end
+
+    def in_web_transaction?
+      !current_transaction.nil? && current_transaction.recording_web_transaction?
+    end
+
+    # Execution tracing on current thread
+    attr_accessor :untraced
+
+    def push_traced(should_trace)
+      @untraced << should_trace
+    end
+
+    def pop_traced
+      @untraced.pop if @untraced
+    end
+
+    def is_execution_traced?
+      @untraced.nil? || @untraced.last != false
+    end
+
+    # TT's and SQL
+    attr_accessor :record_tt, :record_sql
+
+    def is_transaction_traced?
+      @record_tt != false
+    end
+
+    def is_sql_recorded?
+      @record_sql != false
+    end
+
+    # Busy calculator
+    attr_accessor :busy_entries
+
+    # Sql Sampler Transaction Data
+    attr_accessor :sql_sampler_transaction_data
+
+    # Scope stack tracking from OneApm::StatsEngine::Transactions
+    # Should not be nil--this class manages its initialization and resetting
+    attr_reader :traced_method_stack
+  end
+end

data/lib/one_apm/transaction/transaction_summary.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+
+    def summary_metrics
+      if @frozen_name.start_with?(CONTROLLER_PREFIX)
+        [WEB_SUMMARY_METRIC]
+      else
+        background_summary_metrics
+      end
+    end
+
+    def background_summary_metrics
+      segments = @frozen_name.split('/')
+      if segments.size > 2
+        ["OtherTransaction/#{segments[1]}/all", OTHER_SUMMARY_METRIC]
+      else
+        []
+      end
+    end
+
+    def needs_middleware_summary_metrics?(name)
+      name.start_with?(MIDDLEWARE_PREFIX)
+    end
+
+  end
+end

data/lib/one_apm/transaction/transaction_synthetics.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+    module TransactionSynthetics
+
+      attr_accessor :raw_synthetics_header, :synthetics_payload
+
+      def is_synthetics_request?
+        synthetics_payload != nil && raw_synthetics_header != nil
+      end
+
+      def synthetics_version
+        info = synthetics_payload or return nil
+        info[0]
+      end
+
+      def synthetics_account_id
+        info = synthetics_payload or return nil
+        info[1]
+      end
+
+      def synthetics_resource_id
+        info = synthetics_payload or return nil
+        info[2]
+      end
+
+      def synthetics_job_id
+        info = synthetics_payload or return nil
+        info[3]
+      end
+
+      def synthetics_monitor_id
+        info = synthetics_payload or return nil
+        info[4]
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/transaction_timings.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module OneApm
+  class TransactionTimings
+
+    attr_reader :transaction_name,
+                :start_time_in_seconds,
+                :queue_time_in_seconds
+
+    def initialize(queue_time_in_seconds, start_time_in_seconds, transaction_name)
+      @now = Time.now.to_f
+      @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds.to_f)
+      @start_time_in_seconds = clamp_to_positive(start_time_in_seconds.to_f)
+
+      @transaction_name = transaction_name
+    end
+
+    def transaction_name_or_unknown
+      transaction_name || OneApm::Transaction::UNKNOWN_METRIC
+    end
+
+    def start_time_as_time
+      Time.at(@start_time_in_seconds)
+    end
+
+    def start_time_in_millis
+      convert_to_milliseconds(@start_time_in_seconds)
+    end
+
+    def queue_time_in_millis
+      convert_to_milliseconds(queue_time_in_seconds)
+    end
+
+    def app_time_in_millis
+      convert_to_milliseconds(app_time_in_seconds)
+    end
+
+    def app_time_in_seconds
+      @now - @start_time_in_seconds
+    end
+
+    # Helpers
+
+    def convert_to_milliseconds(value_in_seconds)
+      clamp_to_positive((value_in_seconds.to_f * 1000.0).round)
+    end
+
+    def clamp_to_positive(value)
+      return 0.0 if value < 0.0
+      value
+    end
+
+  end
+end

data/lib/one_apm/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module OneApm
+  module VERSION
+
+    MAJOR = 1
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+
+  end
+end