oneapm_rpm 1.1.0

data/lib/one_apm/transaction/transaction_ignore.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+    module TransactionIgnore
+
+      def ignore!
+        @ignore_this_transaction = true
+      end
+
+      def ignore?
+        @ignore_this_transaction
+      end
+
+      def ignore_apdex!
+        @ignore_apdex = true
+      end
+
+      def ignore_apdex?
+        @ignore_apdex
+      end
+
+      def ignore_enduser!
+        @ignore_enduser = true
+      end
+
+      def ignore_enduser?
+        @ignore_enduser
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/transaction_jruby_functions.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+
+    @@java_classes_loaded = false
+
+    if defined? JRuby
+      begin
+        require 'java'
+        java_import 'java.lang.management.ManagementFactory'
+        java_import 'com.sun.management.OperatingSystemMXBean'
+        @@java_classes_loaded = true
+      rescue
+      end
+    end
+
+    JRUBY_CPU_TIME_ERROR = "Error calculating JRuby CPU Time".freeze
+
+    def jruby_cpu_time
+      return nil unless @@java_classes_loaded
+      threadMBean = Java::JavaLangManagement::ManagementFactory.getThreadMXBean()
+
+      return nil unless threadMBean.isCurrentThreadCpuTimeSupported
+      java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+
+      -1 == java_utime ? 0.0 : java_utime/1e9
+    rescue => e
+      ::OneApm::Agent.logger.log_once(:warn, :jruby_cpu_time, JRUBY_CPU_TIME_ERROR, e)
+      ::OneApm::Agent.logger.debug(JRUBY_CPU_TIME_ERROR, e)
+      nil
+    end
+
+    def jruby_cpu_burn
+      return unless @jruby_cpu_start
+      jruby_cpu_time - @jruby_cpu_start
+    end
+
+  end
+end

data/lib/one_apm/transaction/transaction_metrics.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+# This class represents a set of metrics that were recorded during a single
+# transaction. Since the name of the transaction is not known until its end, we
+# don't save explicit scopes with these metrics, we just keep separate
+# collections of scoped and unscoped metrics.
+
+module OneApm
+  class TransactionMetrics
+    DEFAULT_PROC = Proc.new { |hash, name| hash[name] = OneApm::Metrics::Stats.new }
+
+    def initialize
+      @unscoped = Hash.new(&DEFAULT_PROC)
+      @scoped   = Hash.new(&DEFAULT_PROC)
+    end
+
+    def record_scoped(names, value=nil, aux=nil, &blk)
+      _record_metrics(names, value, aux, @scoped, &blk)
+    end
+
+    def record_unscoped(names, value=nil, aux=nil, &blk)
+      _record_metrics(names, value, aux, @unscoped, &blk)
+    end
+
+    def has_key?(key)
+      @unscoped.has_key?(key)
+    end
+
+    def [](key)
+      @unscoped[key]
+    end
+
+    def each_unscoped
+      @unscoped.each { |name, stats| yield name, stats }
+    end
+
+    def each_scoped
+      @scoped.each { |name, stats| yield name, stats }
+    end
+
+    def _record_metrics(names, value, aux, target, &blk)
+      # This looks dumb, but we're avoiding an extra Array allocation.
+      case names
+      when Array
+        names.each do |name|
+          target[name].record(value, aux, &blk)
+        end
+      else
+        target[names].record(value, aux, &blk)
+      end
+    end
+  end
+end

data/lib/one_apm/transaction/transaction_name.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module OneApm
+  class Transaction
+    module TransactionName
+
+      def overridden_name=(name)
+        @overridden_name = Helper.correctly_encoded(name)
+      end
+
+      def default_name=(name)
+        @default_name = Helper.correctly_encoded(name)
+      end
+
+      def make_transaction_name(name, category = nil)
+        "#{OneApm::TransactionNamer.prefix_for_category(self, category)}#{name}"
+      end
+
+      def set_default_transaction_name(name, category)
+        return log_frozen_name(name) if name_frozen?
+        if influences_transaction_name?(category)
+          self.default_name = name
+          @category = category if category
+        end
+      end
+
+      def set_overriding_transaction_name(name, category)
+        return log_frozen_name(name) if name_frozen?
+        if influences_transaction_name?(category)
+          self.overridden_name = name
+          @category = category if category
+        end
+      end
+
+      def name_last_frame(name)
+        frame_stack.last.name = name
+      end
+
+      def log_frozen_name(name)
+        OneApm::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
+        nil
+      end
+
+      def influences_transaction_name?(category)
+        !category || frame_stack.size == 1 || similar_category?(category)
+      end
+
+      def best_name
+        @frozen_name  || @overridden_name ||
+          @default_name || Transaction::UNKNOWN_METRIC
+      end
+
+      def name_set?
+        (@overridden_name || @default_name) ? true : false
+      end
+
+      def promoted_transaction_name(name)
+        if name.start_with?(Transaction::MIDDLEWARE_PREFIX)
+          "#{Transaction::CONTROLLER_PREFIX}#{name}"
+        else
+          name
+        end
+      end
+
+      def freeze_name_and_execute_if_not_ignored
+        if !name_frozen?
+          name = promoted_transaction_name(best_name)
+          name = OneApm::Agent.instance.transaction_rules.rename(name)
+          @name_frozen = true
+
+          if name.nil?
+            ignore!
+            @frozen_name = best_name
+          else
+            @frozen_name = name
+          end
+        end
+
+        if block_given? && !@ignore_this_transaction
+          yield
+        end
+      end
+
+      def name_frozen?
+        @frozen_name ? true : false
+      end
+
+    end
+  end
+end

data/lib/one_apm/transaction/transaction_namer.rb

@@ -0,0 +1,49 @@
+module OneApm
+  class TransactionNamer
+
+    def self.name_for(txn, traced_obj, category, options={})
+      "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
+    end
+
+    def self.prefix_for_category(txn, category = nil)
+      category ||= (txn && txn.category)
+      case category
+      when :controller then ::OneApm::Transaction::CONTROLLER_PREFIX
+      when :task       then ::OneApm::Transaction::TASK_PREFIX
+      when :rack       then ::OneApm::Transaction::RACK_PREFIX
+      when :uri        then ::OneApm::Transaction::CONTROLLER_PREFIX
+      when :sinatra    then ::OneApm::Transaction::SINATRA_PREFIX
+      when :middleware then ::OneApm::Transaction::MIDDLEWARE_PREFIX
+      when :grape      then ::OneApm::Transaction::GRAPE_PREFIX
+      else "#{category.to_s}/" # for internal use only
+      end
+    end
+
+    def self.path_name(traced_obj, options={})
+      return options[:path] if options[:path]
+
+      class_name = class_name(traced_obj, options)
+      if options[:name]
+        if class_name
+          "#{class_name}/#{options[:name]}"
+        else
+          options[:name]
+        end
+      elsif traced_obj.respond_to?(:oneapm_metric_path)
+        traced_obj.oneapm_metric_path
+      else
+        class_name
+      end
+    end
+
+    def self.class_name(traced_obj, options={})
+      return options[:class_name] if options[:class_name]
+      if (traced_obj.is_a?(Class) || traced_obj.is_a?(Module))
+        traced_obj.name
+      else
+        traced_obj.class.name
+      end
+    end
+
+  end
+end

data/lib/one_apm/transaction/transaction_sample.rb

@@ -0,0 +1,204 @@
+# encoding: utf-8
+
+require 'base64'
+
+require 'one_apm/transaction/segment'
+require 'one_apm/transaction/transaction_analysis'
+
+module OneApm
+  # the number of segments that need to exist before we roll them up
+  # into one segment with multiple executions
+  COLLAPSE_SEGMENTS_THRESHOLD = 2
+
+  class TransactionSample
+    include TransactionAnalysis
+
+    attr_accessor :params, :root_segment, :profile, :force_persist, :guid,
+                  :threshold, :finished, :xray_session_id, :start_time,
+                  :synthetics_resource_id
+    attr_reader :root_segment, :params, :sample_id
+    attr_writer :prepared
+
+    @@start_time = Time.now
+
+    def initialize(time = Time.now.to_f, sample_id = nil)
+      @sample_id = sample_id || object_id
+      @start_time = time
+      @params = { :segment_count => -1, :request_params => {} }
+      @segment_count = -1
+      @root_segment = create_segment 0.0, "ROOT"
+      @prepared = false
+    end
+
+    def prepared?
+      @prepared
+    end
+
+    def count_segments
+      @segment_count
+    end
+
+    # makes sure that the parameter cache for segment count is set to
+    # the correct value
+    def ensure_segment_count_set(count)
+      params[:segment_count] ||= count
+    end
+
+    # offset from start of app
+    def timestamp
+      @start_time - @@start_time.to_f
+    end
+
+    def set_custom_param(name, value)
+      @params[:custom_params] ||= {}
+      @params[:custom_params][name] = value
+    end
+
+    include OneApm::Coerce
+
+    def to_array
+      [ float(@start_time),
+        @params[:request_params],
+        @params[:custom_params],
+        @root_segment.to_array ]
+    end
+
+    def to_collector_array(encoder)
+      trace_tree = encoder.encode(self.to_array)
+      [ Helper.time_to_millis(@start_time),
+        Helper.time_to_millis(duration),
+        string(transaction_name),
+        string(@params[:uri]),
+        trace_tree,
+        string(@guid),
+        nil,
+        forced?,
+        int_or_nil(xray_session_id),
+        string(synthetics_resource_id)
+      ]
+    end
+
+    def path_string
+      @root_segment.path_string
+    end
+
+    def transaction_name
+      @params[:path]
+    end
+
+    def transaction_name=(new_name)
+      @params[:path] = new_name
+    end
+
+    def forced?
+      !!@force_persist || !int_or_nil(xray_session_id).nil?
+    end
+
+    # relative_timestamp is seconds since the start of the transaction
+    def create_segment(relative_timestamp, metric_name=nil)
+      raise TypeError.new("Frozen Transaction Sample") if finished
+      @params[:segment_count] += 1
+      @segment_count += 1
+      OneApm::TransactionSample::Segment.new(relative_timestamp, metric_name)
+    end
+
+    def duration
+      root_segment.duration
+    end
+
+    # Iterates recursively over each segment in the entire transaction
+    # sample tree
+    def each_segment(&block)
+      @root_segment.each_segment(&block)
+    end
+
+    # Iterates recursively over each segment in the entire transaction
+    # sample tree while keeping track of nested segments
+    def each_segment_with_nest_tracking(&block)
+      @root_segment.each_segment_with_nest_tracking(&block)
+    end
+
+    def to_s_compact
+      @root_segment.to_s_compact
+    end
+
+    # Searches the tree recursively for the segment with the given
+    # id. note that this is an internal id, not an ActiveRecord id
+    def find_segment(id)
+      @root_segment.find_segment(id)
+    end
+
+    def to_s
+      s = "Transaction Sample collected at #{Time.at(start_time)}\n"
+      s << "  {\n"
+      s << "  Path: #{params[:path]} \n"
+
+      params.each do |k,v|
+        next if k == :path
+        s << "  #{k}: " <<
+        case v
+          when Enumerable then v.map(&:to_s).sort.join("; ")
+          when String then v
+          when Float then '%6.3s' % v
+          when Fixnum then v.to_s
+          when nil then ''
+        else
+          raise "unexpected value type for #{k}: '#{v}' (#{v.class})"
+        end << "\n"
+      end
+      s << "  }\n\n"
+      s <<  @root_segment.to_debug_str(0)
+    end
+
+    # Return a new transaction sample that can be sent to the OneApm service.
+    def prepare_to_send!
+      return self if @prepared
+
+      if Agent::Database.should_record_sql?
+        collect_explain_plans!
+        prepare_sql_for_transmission!
+      else
+        strip_sql!
+      end
+
+      @prepared = true
+      self
+    end
+
+    def params=(params)
+      @params = params
+    end
+
+  private
+
+    def strip_sql!
+      each_segment do |segment|
+        segment.params.delete(:sql)
+      end
+    end
+
+    def collect_explain_plans!
+      return unless Agent::Database.should_collect_explain_plans?
+      threshold = Agent.config[:'transaction_tracer.explain_threshold']
+      each_segment do |segment|
+        if segment[:sql] && segment.duration > threshold
+          segment[:explain_plan] = segment.explain_sql
+        end
+      end
+    end
+
+    def prepare_sql_for_transmission!
+      strategy = Agent::Database.record_sql_method
+      each_segment do |segment|
+        if segment[:sql]
+          segment[:sql] = case strategy
+          when :raw
+            segment[:sql].to_s
+          when :obfuscated
+            Agent::Database.obfuscate_sql(segment[:sql]).to_s
+          end
+        end
+      end
+    end
+  end
+end