oneapm_rpm 1.1.0

data/lib/one_apm/collector/containers/sql_sampler.rb

@@ -0,0 +1,331 @@
+# encoding: utf-8
+
+require 'zlib'
+require 'base64'
+require 'digest/md5'
+
+require 'one_apm/agent'
+require 'one_apm/probe'
+
+module OneApm
+  module Collector
+    # This class contains the logic of recording slow SQL traces, which may
+    # represent multiple aggregated SQL queries.
+    #
+    # A slow SQL trace consists of a collection of SQL instrumented SQL queries
+    # that all normalize to the same text. For example, the following two
+    # queries would be aggregated together into a single slow SQL trace:
+    #
+    #   SELECT * FROM table WHERE id=42
+    #   SELECT * FROM table WHERE id=1234
+    #
+    # Each slow SQL trace keeps track of the number of times the same normalized
+    # query was seen, the min, max, and total time spent executing those
+    # queries, and an example backtrace from one of the aggregated queries.
+    #
+    # @api public
+    class SqlSampler
+
+      # Module defining methods stubbed out when the agent is disabled
+      module Shim
+        def on_start_transaction(*args); end
+        def on_finishing_transaction(*args); end
+      end
+
+      attr_reader :disabled
+
+      # this is for unit tests only
+      attr_reader :sql_traces
+
+      MAX_SAMPLES = 10
+
+      def initialize
+        @sql_traces = {}
+
+        # This lock is used to synchronize access to @sql_traces
+        # and related variables. It can become necessary on JRuby or
+        # any 'honest-to-god'-multithreaded system
+        @samples_lock = Mutex.new
+      end
+
+      def enabled?
+        Agent.config[:'slow_sql.enabled'] &&
+          Agent.config[:'transaction_tracer.enabled'] &&
+          OneApm::Agent::Database.should_record_sql?(:slow_sql)
+      end
+
+      def on_start_transaction(state, start_time, uri=nil)
+        return unless enabled?
+
+        state.sql_sampler_transaction_data = TransactionSqlData.new
+
+        if state.transaction_sample_builder
+          guid = state.transaction_sample_builder.sample.guid
+        end
+
+        if Agent.config[:'slow_sql.enabled'] && state.sql_sampler_transaction_data
+          state.sql_sampler_transaction_data.set_transaction_info(uri, guid)
+        end
+      end
+
+      def tl_transaction_data # only used for testing
+        OneApm::TransactionState.tl_get.sql_sampler_transaction_data
+      end
+
+      # This is called when we are done with the transaction.
+      def on_finishing_transaction(state, name, time=Time.now)
+        return unless enabled?
+
+        data = state.sql_sampler_transaction_data
+        return unless data
+
+        data.set_transaction_name(name)
+        if data.sql_data.size > 0
+          @samples_lock.synchronize do
+            ::OneApm::Agent.logger.debug "Examining #{data.sql_data.size} slow transaction sql statement(s)"
+            save_slow_sql data
+          end
+        end
+      end
+
+      # this should always be called under the @samples_lock
+      def save_slow_sql(transaction_sql_data)
+        path = transaction_sql_data.path
+        uri  = transaction_sql_data.uri
+
+        transaction_sql_data.sql_data.each do |sql_item|
+          normalized_sql = sql_item.normalize
+          sql_trace = @sql_traces[normalized_sql]
+          if sql_trace
+            sql_trace.aggregate(sql_item, path, uri)
+          else
+            if has_room?
+              sql_trace = SqlTrace.new(normalized_sql, sql_item, path, uri)
+            elsif should_add_trace?(sql_item)
+              remove_shortest_trace
+              sql_trace = SqlTrace.new(normalized_sql, sql_item, path, uri)
+            end
+
+            if sql_trace
+              @sql_traces[normalized_sql] = sql_trace
+            end
+          end
+        end
+      end
+
+      # this should always be called under the @samples_lock
+      def should_add_trace?(sql_item)
+        @sql_traces.any? do |(_, existing_trace)|
+          existing_trace.max_call_time < sql_item.duration
+        end
+      end
+
+      # this should always be called under the @samples_lock
+      def has_room?
+        @sql_traces.size < MAX_SAMPLES
+      end
+
+      # this should always be called under the @samples_lock
+      def remove_shortest_trace
+        shortest_key, _ = @sql_traces.min_by { |(_, trace)| trace.max_call_time }
+        @sql_traces.delete(shortest_key)
+      end
+
+      # Records an SQL query, potentially creating a new slow SQL trace, or
+      # aggregating the query into an existing slow SQL trace.
+      #
+      # This method should be used only by gem authors wishing to extend
+      # the Ruby agent to instrument new database interfaces - it should
+      # generally not be called directly from application code.
+      #
+      # @param sql [String] the SQL query being recorded
+      # @param metric_name [String] is the metric name under which this query will be recorded
+      # @param config [Object] is the driver configuration for the connection
+      # @param duration [Float] number of seconds the query took to execute
+      # @param explainer [Proc] for internal use only - 3rd-party clients must
+      #                         not pass this parameter.
+      #
+      # @api public
+      #
+      def notice_sql(sql, metric_name, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
+        state ||= OneApm::TransactionState.tl_get
+        data = state.sql_sampler_transaction_data
+        return unless data
+
+        if state.is_sql_recorded?
+          if duration > Agent.config[:'slow_sql.explain_threshold']
+            backtrace = caller
+            backtrace.reject! { |t| t.include?('one_apm') }
+            data.sql_data << SlowSql.new(OneApm::Agent::Database.capture_query(sql),
+                                         metric_name, config,
+                                         duration, backtrace, &explainer)
+          end
+        end
+      end
+
+      def merge!(sql_traces)
+        @samples_lock.synchronize do
+          sql_traces.each do |trace|
+            existing_trace = @sql_traces[trace.sql]
+            if existing_trace
+              existing_trace.aggregate_trace(trace)
+            else
+              @sql_traces[trace.sql] = trace
+            end
+          end
+        end
+      end
+
+      def harvest!
+        return [] unless enabled?
+
+        slowest = []
+        @samples_lock.synchronize do
+          slowest = @sql_traces.values
+          @sql_traces = {}
+        end
+        slowest.each {|trace| trace.prepare_to_send }
+        slowest
+      end
+
+      def reset!
+        @samples_lock.synchronize do
+          @sql_traces = {}
+        end
+      end
+    end
+
+    class TransactionSqlData
+      attr_reader :path
+      attr_reader :uri
+      attr_reader :sql_data
+      attr_reader :guid
+
+      def initialize
+        @sql_data = []
+      end
+
+      def set_transaction_info(uri, guid)
+        @uri = uri
+        @guid = guid
+      end
+
+      def set_transaction_name(name)
+        @path = name
+      end
+    end
+
+    class SlowSql
+      attr_reader :sql
+      attr_reader :metric_name
+      attr_reader :duration
+      attr_reader :backtrace
+
+      def initialize(sql, metric_name, config, duration, backtrace=nil,
+                     &explainer)
+        @sql = sql
+        @metric_name = metric_name
+        @config = config
+        @duration = duration
+        @backtrace = backtrace
+        @explainer = explainer
+      end
+
+      def obfuscate
+        OneApm::Agent::Database.obfuscate_sql(@sql)
+      end
+
+      def normalize
+        OneApm::Agent::Database::Obfuscator.instance \
+          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
+      end
+
+      def explain
+        if @config && @explainer
+          OneApm::Agent::Database.explain_sql(@sql, @config, &@explainer)
+        end
+      end
+
+      # We can't serialize the explainer, so clear it before we transmit
+      def prepare_to_send
+        @explainer = nil
+      end
+    end
+
+    class SqlTrace < OneApm::Metrics::Stats
+      attr_reader :path
+      attr_reader :url
+      attr_reader :sql_id
+      attr_reader :sql
+      attr_reader :database_metric_name
+      attr_reader :params
+      attr_reader :slow_sql
+
+      def initialize(normalized_query, slow_sql, path, uri)
+        super()
+        @params = {}
+        @sql_id = consistent_hash(normalized_query)
+        set_primary slow_sql, path, uri
+        record_data_point(float(slow_sql.duration))
+      end
+
+      def set_primary(slow_sql, path, uri)
+        @slow_sql = slow_sql
+        @sql = slow_sql.sql
+        @database_metric_name = slow_sql.metric_name
+        @path = path
+        @url = uri
+        @params[:backtrace] = slow_sql.backtrace if slow_sql.backtrace
+      end
+
+      def aggregate(slow_sql, path, uri)
+        if slow_sql.duration > max_call_time
+          set_primary slow_sql, path, uri
+        end
+
+        record_data_point(float(slow_sql.duration))
+      end
+
+      def aggregate_trace(trace)
+        aggregate(trace.slow_sql, trace.path, trace.url)
+      end
+
+      def prepare_to_send
+        params[:explain_plan] = @slow_sql.explain if need_to_explain?
+        @sql = @slow_sql.obfuscate if need_to_obfuscate?
+        @slow_sql.prepare_to_send
+      end
+
+      def need_to_obfuscate?
+        Agent.config[:'slow_sql.record_sql'].to_s == 'obfuscated'
+      end
+
+      def need_to_explain?
+        Agent.config[:'slow_sql.explain_enabled']
+      end
+
+      include OneApm::Coerce
+
+      def to_collector_array(encoder)
+        [ string(@path),
+          string(@url),
+          int(@sql_id),
+          string(@sql),
+          string(@database_metric_name),
+          int(@call_count),
+          Helper.time_to_millis(@total_call_time),
+          Helper.time_to_millis(@min_call_time),
+          Helper.time_to_millis(@max_call_time),
+          encoder.encode(@params) ]
+      end
+
+      private
+
+      def consistent_hash(string)
+        # need to hash the same way in every process
+        Digest::MD5.hexdigest(string).hex \
+          .modulo(2**31-1)  # ensure sql_id fits in an INT(11)
+      end
+    end
+  end
+end

data/lib/one_apm/collector/containers/stats_engine.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'one_apm/collector/stats_engine/metric_stats'
+require 'one_apm/collector/stats_engine/gc_profiler'
+require 'one_apm/collector/stats_engine/stats_hash'
+
+module OneApm
+  module Collector
+    # This class handles all the statistics gathering for the agent
+    class StatsEngine
+      include MetricStats
+
+      module Shim
+        def add_sampler(*args); end
+        def add_harvest_sampler(*args); end
+        def start_sampler_thread(*args); end
+      end
+
+      attr_accessor :metric_rules
+
+      def initialize
+        @stats_lock   = Mutex.new
+        @stats_hash   = StatsHash.new
+        @metric_rules = OneApm::Support::RulesEngine.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

data/lib/one_apm/collector/containers/transaction_event_aggregator.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+
+require 'monitor'
+
+class OneApm::Collector::TransactionEventAggregator
+  include OneApm::Coerce, MonitorMixin
+
+  # The type field of the sample
+  SAMPLE_TYPE                    = 'Transaction'.freeze
+
+  # Strings for static keys of the sample structure
+  TYPE_KEY                       = 'type'.freeze
+  TIMESTAMP_KEY                  = 'timestamp'.freeze
+  NAME_KEY                       = 'name'.freeze
+  DURATION_KEY                   = 'duration'.freeze
+  HTTP_RESPONSE_CODE_KEY         = 'httpResponseCode'.freeze
+  GUID_KEY                       = 'bw.guid'.freeze
+  REFERRING_TRANSACTION_GUID_KEY = 'bw.referringTransactionGuid'.freeze
+  CAT_TRIP_ID_KEY                = 'bw.tripId'.freeze
+  CAT_PATH_HASH_KEY              = 'bw.pathHash'.freeze
+  CAT_REFERRING_PATH_HASH_KEY    = 'bw.referringPathHash'.freeze
+  CAT_ALTERNATE_PATH_HASHES_KEY  = 'bw.alternatePathHashes'.freeze
+  APDEX_PERF_ZONE_KEY            = 'bw.apdexPerfZone'.freeze
+  SYNTHETICS_RESOURCE_ID_KEY     = "bw.syntheticsResourceId".freeze
+  SYNTHETICS_JOB_ID_KEY          = "bw.syntheticsJobId".freeze
+  SYNTHETICS_MONITOR_ID_KEY      = "bw.syntheticsMonitorId".freeze
+
+  def initialize(event_listener)
+    super()
+
+    @enabled       = false
+    @notified_full = false
+
+    @samples            = ::OneApm::Agent::SampledBuffer.new(OneApm::Agent.config[:'analytics_events.max_samples_stored'])
+    @synthetics_samples = ::OneApm::Agent::SyntheticsEventBuffer.new(OneApm::Agent.config[:'synthetics.events_limit'])
+
+    event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
+    self.register_config_callbacks
+  end
+
+  # Fetch a copy of the sampler's gathered samples. (Synchronized)
+  def samples
+    self.synchronize { @samples.to_a.concat(@synthetics_samples.to_a) }
+  end
+
+  def reset!
+    sample_count, request_count, synthetics_dropped = 0
+    old_samples = nil
+
+    self.synchronize do
+      sample_count = @samples.size
+      request_count = @samples.num_seen
+
+      synthetics_dropped = @synthetics_samples.num_dropped
+
+      old_samples = @samples.to_a + @synthetics_samples.to_a
+      @samples.reset!
+      @synthetics_samples.reset!
+
+      @notified_full = false
+    end
+
+    [old_samples, sample_count, request_count, synthetics_dropped]
+  end
+
+  # Clear any existing samples, reset the last sample time, and return the
+  # previous set of samples. (Synchronized)
+  def harvest!
+    old_samples, sample_count, request_count, synthetics_dropped = reset!
+    record_sampling_rate(request_count, sample_count) if @enabled
+    record_dropped_synthetics(synthetics_dropped)
+    old_samples
+  end
+
+  # Merge samples back into the buffer, for example after a failed
+  # transmission to the collector. (Synchronized)
+  def merge!(old_samples)
+    self.synchronize do
+      old_samples.each { |s| append_event(s) }
+    end
+  end
+
+  def record_sampling_rate(request_count, sample_count) #THREAD_LOCAL_ACCESS
+    request_count_lifetime = @samples.seen_lifetime
+    sample_count_lifetime = @samples.captured_lifetime
+    OneApm::Agent.logger.debug("Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup" % [
+      sample_count,
+      request_count,
+      (sample_count.to_f / request_count * 100.0),
+      sample_count_lifetime,
+      request_count_lifetime,
+      (sample_count_lifetime.to_f / request_count_lifetime * 100.0)
+    ])
+
+    engine = OneApm::Agent.instance.stats_engine
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/requests", request_count)
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/samples", sample_count)
+  end
+
+  def record_dropped_synthetics(synthetics_dropped)
+    return unless synthetics_dropped > 0
+
+    OneApm::Agent.logger.debug("Synthetics transaction event limit (#{@samples.capacity}) reached. Further synthetics events this harvest period dropped.")
+
+    engine = OneApm::Agent.instance.stats_engine
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/synthetics_events_dropped", synthetics_dropped)
+  end
+
+  def register_config_callbacks
+    OneApm::Agent.config.register_callback(:'analytics_events.max_samples_stored') do |max_samples|
+      OneApm::Agent.logger.debug "TransactionEventAggregator max_samples set to #{max_samples}"
+      self.synchronize { @samples.capacity = max_samples }
+    end
+
+    OneApm::Agent.config.register_callback(:'synthetics.events_limit') do |max_samples|
+      OneApm::Agent.logger.debug "TransactionEventAggregator limit for synthetics events set to #{max_samples}"
+      self.synchronize { @synthetics_samples.capacity = max_samples }
+    end
+
+    OneApm::Agent.config.register_callback(:'analytics_events.enabled') do |enabled|
+      @enabled = enabled
+    end
+  end
+
+  def notify_full
+    OneApm::Agent.logger.debug "Transaction event capacity of #{@samples.capacity} reached, beginning sampling"
+    @notified_full = true
+  end
+
+  # Event handler for the :transaction_finished event.
+  def on_transaction_finished(payload)
+    return unless @enabled
+
+    main_event = create_main_event(payload)
+    custom_params = create_custom_parameters(payload)
+
+    self.synchronize { append_event([main_event, custom_params]) }
+    notify_full if !@notified_full && @samples.full?
+  end
+
+  def append_event(event)
+    main_event, _ = event
+
+    if main_event.include?(SYNTHETICS_RESOURCE_ID_KEY)
+      # Try adding to synthetics buffer. If anything is rejected, give it a
+      # shot in the main transaction events (where it may get sampled)
+      result, rejected = @synthetics_samples.append_with_reject(event)
+
+      if rejected
+        @samples.append(rejected)
+      end
+    else
+      @samples.append(event)
+    end
+  end
+
+  def self.map_metric(metric_name, to_add={})
+    to_add.values.each(&:freeze)
+
+    mappings = OVERVIEW_SPECS.fetch(metric_name, {})
+    mappings.merge!(to_add)
+
+    OVERVIEW_SPECS[metric_name] = mappings
+  end
+
+  OVERVIEW_SPECS = {}
+
+  # All Transactions
+  # Don't need to use the transaction-type specific metrics since this is
+  # scoped to just one transaction, so Datastore/all has what we want.
+  map_metric('Datastore/all',         :total_call_time => "databaseDuration")
+  map_metric('Datastore/all',         :call_count      => "databaseCallCount")
+  map_metric('GC/Transaction/all',    :total_call_time => "gcCumulative")
+
+  # Web Metrics
+  map_metric('WebFrontend/QueueTime', :total_call_time => "queueDuration")
+  map_metric('Memcache/allWeb',       :total_call_time => "memcacheDuration")
+
+  map_metric('External/allWeb',       :total_call_time => "externalDuration")
+  map_metric('External/allWeb',       :call_count      => "externalCallCount")
+
+  # Background Metrics
+  map_metric('Memcache/allOther',     :total_call_time => "memcacheDuration")
+
+  map_metric('External/allOther',     :total_call_time => "externalDuration")
+  map_metric('External/allOther',     :call_count      => "externalCallCount")
+
+  def append_metrics(txn_metrics, sample)
+    if txn_metrics
+      OVERVIEW_SPECS.each do |(name, extracted_values)|
+        if txn_metrics.has_key?(name)
+          stat = txn_metrics[name]
+          extracted_values.each do |value_name, key_name|
+            sample[key_name] = stat.send(value_name)
+          end
+        end
+      end
+    end
+  end
+
+  def create_main_event(payload)
+    sample = {
+      TIMESTAMP_KEY => float(payload[:start_timestamp]),
+      NAME_KEY      => string(payload[:name]),
+      DURATION_KEY  => float(payload[:duration]),
+      TYPE_KEY      => SAMPLE_TYPE,
+    }
+    append_metrics(payload[:metrics], sample)
+    optionally_append(GUID_KEY,                       :guid, sample, payload)
+    optionally_append(REFERRING_TRANSACTION_GUID_KEY, :referring_transaction_guid, sample, payload)
+    optionally_append(CAT_TRIP_ID_KEY,                :cat_trip_id, sample, payload)
+    optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
+    optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
+    optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
+    optionally_append(SYNTHETICS_RESOURCE_ID_KEY,     :synthetics_resource_id, sample, payload)
+    optionally_append(SYNTHETICS_JOB_ID_KEY,          :synthetics_job_id, sample, payload)
+    optionally_append(SYNTHETICS_MONITOR_ID_KEY,      :synthetics_monitor_id, sample, payload)
+    append_http_response_code(sample, payload)
+    append_cat_alternate_path_hashes(sample, payload)
+    sample
+  end
+
+  def append_http_response_code(sample, payload)
+    unless OneApm::Agent.config[:disable_rack_middleware]
+      optionally_append(HTTP_RESPONSE_CODE_KEY, :http_response_code, sample, payload)
+    end
+  end
+
+  def append_cat_alternate_path_hashes(sample, payload)
+    if payload.include?(:cat_alternate_path_hashes)
+      sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(',')
+    end
+  end
+
+  def optionally_append(sample_key, payload_key, sample, payload)
+    if payload.include?(payload_key)
+      sample[sample_key] = string(payload[payload_key])
+    end
+  end
+
+  def create_custom_parameters(payload)
+    custom_params = {}
+    if ::OneApm::Agent.config[:'analytics_events.capture_attributes']
+      custom_params.merge!(event_params(payload[:custom_params] || {}))
+    end
+    custom_params
+  end
+
+end