tingyun_rpm 1.0.6

data/lib/ting_yun/agent/collector/stats_engine/metric_stats.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Agent
+    module Collector
+      class StatsEngine
+        module MetricStats
+          # Handles methods related to actual Metric collection
+
+          SCOPE_PLACEHOLDER = '__SCOPE__'.freeze
+
+          # Update the unscoped metrics given in metric_names.
+          # metric_names may be either a single name, or an array of names.
+          #
+          # This is an internal method, subject to change at any time. Client apps
+          # and gems should use the public API (TingYun::Agent.record_metric)
+          # instead.
+          #
+          # There are four ways to use this method:
+          #
+          # 1. With a numeric value, it will update the Stats objects associated
+          #    with the given metrics by calling record_data_point(value, aux).
+          #    aux will be treated in this case as the exclusive time associated
+          #    with the call being recorded.
+          #
+          # 2. With a value of :apdex_s, :apdex_t, or :apdex_f, it will treat the
+          #    associated stats as an Apdex metric, updating it to reflect the
+          #    occurrence of a transaction falling into the given category.
+          #    The aux value in this case should be the apdex threshold used in
+          #    bucketing the request.
+          #
+          # 3. If a block is given, value and aux will be ignored, and instead the
+          #    Stats object associated with each named unscoped metric will be
+          #    yielded to the block for customized update logic.
+          #
+          # 4. If value is a Stats instance, it will be merged into the Stats
+          #    associated with each named unscoped metric.
+          #
+          # If this method is called during a transaction, the metrics will be
+          # attached to the Transaction, and not merged into the global set until
+          # the end of the transaction.
+          #
+          # Otherwise, the metrics will be recorded directly into the global set
+          # of metrics, under a lock.
+          #
+          # @api private
+          #
+
+
+          def tl_record_unscoped_metrics(metric_names, value=nil, aux=nil, &blk)
+            state = TingYun::Agent::TransactionState.tl_get
+            record_unscoped_metrics(state, metric_names, value, aux, &blk)
+          end
+
+          def record_unscoped_metrics(state, metric_names, value=nil, aux=nil,  &blk)
+            txn = state.current_transaction
+
+            if txn
+              txn.metrics.record_unscoped(metric_names, value, aux, &blk)
+            else
+              specs = coerce_to_metric_spec_array(metric_names, nil)
+              with_stats_lock do
+                @stats_hash.record(specs, value, aux, &blk)
+              end
+            end
+          end
+
+          # Like tl_record_unscoped_metrics, but records a scoped metric as well.
+          #
+          # This is an internal method, subject to change at any time. Client apps
+          # and gems should use the public API (TingYun::Agent.record_metric)
+          # instead.
+          #
+          # The given scoped_metric will be recoded as both a scoped *and* an
+          # unscoped metric. The summary_metrics will be recorded as unscoped
+          # metrics only.
+          #
+          # If called during a transaction, all metrics will be attached to the
+          # Transaction, and not merged into the global set of metrics until the
+          # end of the transaction.
+          #
+          # If called outside of a transaction, only the *unscoped* metrics will
+          # be recorded, directly into the global set of metrics (under a lock).
+          #
+          # @api private
+
+          def tl_record_scoped_and_unscoped_metrics(scoped_metric, summary_metrics=nil, value=nil, aux=nil, &blk)
+            state = TingYun::Agent::TransactionState.tl_get
+            record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics, value, aux, &blk)
+          end
+
+          def record_scoped_and_unscoped_metrics(state, scoped_metric, summary_metrics=nil, value=nil, aux=nil ,&blk)
+            txn = state.current_transaction
+
+            if txn
+              txn.metrics.record_scoped(scoped_metric, value, aux, &blk)
+              txn.metrics.record_unscoped(scoped_metric, value, aux, &blk)
+              if summary_metrics
+                txn.metrics.record_unscoped(summary_metrics, value, aux, &blk)
+              end
+            else
+              specs = coerce_to_metric_spec_array(scoped_metric, nil)
+              if summary_metrics
+                specs.concat(coerce_to_metric_spec_array(summary_metrics, nil))
+              end
+              with_stats_lock do
+                @stats_hash.record(specs, value, aux, &blk)
+              end
+            end
+          end
+
+          def coerce_to_metric_spec_array(metric_names_or_specs, scope)
+            specs = []
+            Array(metric_names_or_specs).map do |name_or_spec|
+              case name_or_spec
+                when String
+                  specs << TingYun::Metrics::MetricSpec.new(name_or_spec)
+                  specs << TingYun::Metrics::MetricSpec.new(name_or_spec, scope) if scope
+                when TingYun::Metrics::MetricSpec
+                  specs << name_or_spec
+              end
+            end
+            specs
+          end
+
+          def reset!
+            with_stats_lock do
+              old = @stats_hash
+              @stats_hash = StatsHash.new
+              old
+            end
+          end
+
+          def harvest!
+            now = Time.now
+            snapshot = reset!
+            snapshot.harvested_at = now
+            snapshot
+          end
+
+          # Renamed to reset!, here for backwards compatibility with 3rd-party
+          # gems (though this really isn't part of the public API).
+          # @deprecated
+          def reset_stats; reset!; end
+
+          # merge data from previous harvests into this stats engine
+          def merge!(other_stats_hash)
+            with_stats_lock do
+              @stats_hash.merge!(other_stats_hash)
+              @stats_hash
+            end
+          end
+
+          # For use by test code only.
+          def to_h
+            with_stats_lock { @stats_hash.to_h }
+          end
+
+          def merge_transaction_metrics!(txn_metrics, scope)
+            with_stats_lock do
+              @stats_hash.merge_transaction_metrics!(txn_metrics, scope)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/stats_engine/stats_hash.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+
+# A Hash-like class for storing perfMetrics data.
+#
+# Internally, metrics are split into unscoped and scoped collections.
+#
+# Unscoped metrics are stored in a Hash, keyed by Strings representing the name
+# of the metrics.
+#
+# Scoped metrics are stored in a Hash where the keys are TingYun::Metrics::MetricSpec
+# objects (effectively <name, scope> tuples).
+#
+# Values in both hashes are TingYun::Metrics::Stats objects.
+#
+# Missing keys will be automatically created as empty TingYun::Metrics::Stats
+# instances, so use has_key? explicitly to check for key existence.
+#
+# Note that instances of this class are intended to be append-only with respect
+# to new metrics. That is, you should not attempt to *remove* an entry after it
+# has been added, only update it (create a new instance if you need to start
+# over with a blank slate).
+#
+# This class makes no provisions for safe usage from multiple threads, such
+# measures should be externally provided.
+
+require 'ting_yun/metrics/stats'
+require 'ting_yun/metrics/metric_spec'
+require 'ting_yun/support/exception'
+
+module TingYun
+  module Agent
+    module Collector
+      class StatsHash
+
+        attr_accessor :started_at, :harvested_at
+
+        def initialize(started_at=Time.now)
+          @started_at = started_at.to_f
+          @scoped = Hash.new { |h, k| h[k] = TingYun::Metrics::Stats.new }
+          @unscoped = Hash.new { |h, k| h[k] = TingYun::Metrics::Stats.new }
+        end
+
+        def marshal_dump
+          [@started_at, Hash[@scoped], Hash[@unscoped]]
+        end
+
+        def marshal_load(data)
+          @started_at = data.shift
+          @scoped = Hash.new { |h, k| h[k] = TingYun::Metrics::Stats.new }
+          @unscoped = Hash.new { |h, k| h[k] = TingYun::Metrics::Stats.new }
+          @scoped.merge!(data.shift)
+          @unscoped.merge!(data.shift)
+        end
+
+        def ==(other)
+          self.to_h == other.to_h
+        end
+
+        def to_h
+          hash = {}
+          @scoped.each { |k, v| hash[k] = v }
+          @unscoped.each { |k, v| hash[TingYun::Metrics::MetricSpec.new(k)] = v }
+          hash
+        end
+
+        def [](key)
+          case key
+            when String
+              @unscoped[key]
+            when TingYun::Metrics::MetricSpec
+              if key.scope.empty?
+                @unscoped[key.name]
+              else
+                @scoped[key]
+              end
+          end
+        end
+
+        def each
+          @scoped.each do |k, v|
+            yield k, v
+          end
+          @unscoped.each do |k, v|
+            spec = TingYun::Metrics::MetricSpec.new(k)
+            yield spec, v
+          end
+        end
+
+        def empty?
+          @unscoped.empty? && @scoped.empty?
+        end
+
+        def size
+          @unscoped.size + @scoped.size
+        end
+
+        def merge!(other)
+          @started_at = other.started_at if other.started_at < @started_at
+
+          other.each do |spec, val|
+            if spec.scope.empty?
+              merge_or_insert(@unscoped, spec.name, val)
+            else
+              merge_or_insert(@scoped, spec, val)
+            end
+          end
+          self
+        end
+
+        class StatsHashLookupError < TingYun::Support::Exception::InternalAgentError
+          def initialize(original_error, hash, metric_spec)
+            super("Lookup error in StatsHash: #{original_error.class}: #{original_error.message}. Falling back adding #{metric_spec.inspect}")
+          end
+        end
+
+        def record(metric_specs, value=nil, aux=nil, &blk)
+          Array(metric_specs).each do |metric_spec|
+            if metric_spec.scope.empty?
+              key = metric_spec.name
+              hash = @unscoped
+            else
+              key = metric_spec
+              hash = @scoped
+            end
+
+            begin
+              stats = hash[key]
+            rescue NoMethodError => e
+              stats = handle_stats_lookup_error(key, hash, e)
+            end
+
+            stats.record(value, aux, &blk)
+          end
+        end
+
+        def merge_transaction_metrics!(txn_metrics, scope)
+
+          txn_metrics.each_unscoped do |name, stats|
+            merge_or_insert(@unscoped, name, stats)
+          end
+          txn_metrics.each_scoped do |name, stats|
+            spec = TingYun::Metrics::MetricSpec.new(name, scope)
+            merge_or_insert(@scoped, spec, stats)
+          end
+        end
+
+        def merge_or_insert(target, name, stats)
+          if target.has_key?(name)
+            target[name].merge!(stats)
+          else
+            target[name] = stats
+          end
+        end
+
+        def handle_stats_lookup_error(key, hash, error)
+          # This only happen in the case of a corrupted default_proc
+          # Side-step it manually, notice the issue, and carry on....
+          ::TingYun::Agent.instance.error_collector. \
+          notice_agent_error(StatsHashLookupError.new(error, hash, key))
+          stats = TingYun::Metrics::Stats.new
+          hash[key] = stats
+          # Try to restore the default_proc so we won't continually trip the error
+          if hash.respond_to?(:default_proc=)
+            hash.default_proc = Proc.new { |h, k| h[k] = TingYun::Metrics::Stats.new }
+          end
+          stats
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/stats_engine.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'ting_yun/agent/collector/stats_engine/stats_hash'
+require 'ting_yun/agent/collector/stats_engine/metric_stats'
+
+module TingYun
+  module Agent
+    module Collector
+      # This class handles all the statistics gathering for the agent
+      class StatsEngine
+
+        include MetricStats
+
+
+        def initialize
+          @stats_lock = Mutex.new
+          @stats_hash = StatsHash.new
+        end
+
+        # All access to the @stats_hash ivar should be funnelled through this
+        # method to ensure thread-safety.
+        def with_stats_lock
+          @stats_lock.synchronize { yield }
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/transaction_sampler/slowest_sample_buffer.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+require 'ting_yun/agent/collector/transaction_sampler/transaction_sample_buffer_base'
+module TingYun
+  module Agent
+    module Collector
+      class TransactionSampler
+        class SlowestSampleBuffer < TransactionSampleBufferBase
+
+          CAPACITY = 1
+
+          def capacity
+            CAPACITY
+          end
+
+          def allow_sample?(sample)
+            sample.threshold && sample.duration >= sample.threshold
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/transaction_sampler/transaction_sample_buffer_base.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Agent
+    module Collector
+      class TransactionSampler
+        class TransactionSampleBufferBase
+
+          SINGLE_BUFFER_MAX = 20
+          NO_SAMPLES = [].freeze
+
+          def initialize
+            @samples = []
+          end
+
+          #If a buffer needs to modify, override this method.
+          def allow_sample?(sample)
+            true
+          end
+
+          #If a buffer needs to modify, override this method.
+          def enabled?
+            true
+          end
+
+          def reset!
+            @samples = []
+          end
+
+          def harvest_samples
+            @samples
+          ensure
+            reset!
+          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("TransactionSampleBufferBase subclasses must provide a capacity override")
+          end
+
+          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.
+          def truncate_samples
+            @samples.sort!{|a,b| a.duration <=> b.duration}
+            @samples.slice!(0..-(max_capacity + 1))
+          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
+  end
+end
+