mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/sql_sampler.rb

@@ -0,0 +1,322 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'zlib'
+require 'base64'
+require 'digest/md5'
+
+module Mmtrix
+  module Agent
+    # 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
+      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'] &&
+          Mmtrix::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
+        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
+            ::Mmtrix::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
+      # @deprecated Use {Datastores.notice_sql} instead.
+      #
+      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
+        state ||= 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.join("\n")
+            data.sql_data << SlowSql.new(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=nil)
+        @sql = sql
+        @metric_name = metric_name
+        @config = config
+        @duration = duration
+        @backtrace = backtrace
+        @explainer = explainer
+      end
+
+      def obfuscate
+        Mmtrix::Agent::Database.obfuscate_sql(@sql)
+      end
+
+      def normalize
+        Mmtrix::Agent::Database::Obfuscator.instance \
+          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
+      end
+
+      def explain
+        if @config && @explainer
+          Mmtrix::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 < 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 Mmtrix::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/mmtrix/agent/stats.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+module Mmtrix
+  module Agent
+    class Stats
+      attr_accessor :call_count
+      attr_accessor :min_call_time
+      attr_accessor :max_call_time
+      attr_accessor :total_call_time
+      attr_accessor :total_exclusive_time
+      attr_accessor :sum_of_squares
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @call_count = 0
+        @total_call_time = 0.0
+        @total_exclusive_time = 0.0
+        @min_call_time = 0.0
+        @max_call_time = 0.0
+        @sum_of_squares = 0.0
+      end
+
+      def is_reset?
+        call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
+      end
+
+      def merge(other_stats)
+        stats = self.clone
+        stats.merge!(other_stats)
+      end
+
+      def merge!(other)
+        @min_call_time = other.min_call_time if min_time_less?(other)
+        @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+        @total_call_time      += other.total_call_time
+        @total_exclusive_time += other.total_exclusive_time
+        @sum_of_squares       += other.sum_of_squares
+        @call_count += other.call_count
+        self
+      end
+
+      def to_s
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
+      end
+
+      def to_json(*_)
+        {
+          'call_count'           => call_count.to_i,
+          'min_call_time'        => min_call_time.to_f,
+          'max_call_time'        => max_call_time.to_f,
+          'total_call_time'      => total_call_time.to_f,
+          'total_exclusive_time' => total_exclusive_time.to_f,
+          'sum_of_squares'       => sum_of_squares.to_f
+        }.to_json(*_)
+      end
+
+      def record(value=nil, aux=nil, &blk)
+        if blk
+          yield self
+        else
+          case value
+          when Numeric
+            aux ||= value
+            self.record_data_point(value, aux)
+          when :apdex_s, :apdex_t, :apdex_f
+            self.record_apdex(value, aux)
+          when Mmtrix::Agent::Stats
+            self.merge!(value)
+          end
+        end
+      end
+
+      # record a single data point into the statistical gatherer.  The gatherer
+      # will aggregate all data points collected over a specified period and upload
+      # its data to the Mmtrix server
+      def record_data_point(value, exclusive_time = value)
+        @call_count += 1
+        @total_call_time += value
+        @min_call_time = value if value < @min_call_time || @call_count == 1
+        @max_call_time = value if value > @max_call_time
+        @total_exclusive_time += exclusive_time
+
+        @sum_of_squares += (value * value)
+        self
+      end
+
+      alias trace_call record_data_point
+
+      # increments the call_count by one
+      def increment_count(value = 1)
+        @call_count += value
+      end
+
+      # Concerned about implicit usage of inspect relying on stats format, so
+      # putting back a version to get full inspection as separate method
+      def inspect_full
+        variables = instance_variables.map do |ivar|
+          "#{ivar.to_s}=#{instance_variable_get(ivar).inspect}"
+        end.join(" ")
+        "#<Mmtrix::Agent::Stats #{variables}>"
+      end
+
+      def ==(other)
+        other.class == self.class &&
+        (
+          @min_call_time        == other.min_call_time &&
+          @max_call_time        == other.max_call_time &&
+          @total_call_time      == other.total_call_time &&
+          @total_exclusive_time == other.total_exclusive_time &&
+          @sum_of_squares       == other.sum_of_squares &&
+          @call_count           == other.call_count
+        )
+      end
+
+      # Apdex-related accessors
+      alias_method :apdex_s, :call_count
+      alias_method :apdex_t, :total_call_time
+      alias_method :apdex_f, :total_exclusive_time
+
+      def record_apdex(bucket, apdex_t)
+        case bucket
+        when :apdex_s then @call_count += 1
+        when :apdex_t then @total_call_time += 1
+        when :apdex_f then @total_exclusive_time += 1
+        end
+        if apdex_t
+          @min_call_time = apdex_t
+          @max_call_time = apdex_t
+        else
+          ::Mmtrix::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+        end
+      end
+
+      protected
+
+      def min_time_less?(other)
+        (other.min_call_time < min_call_time && other.call_count > 0) || call_count == 0
+      end
+    end
+
+    class ChainedStats
+      attr_accessor :scoped_stats, :unscoped_stats
+
+      def initialize(scoped_stats, unscoped_stats)
+        @scoped_stats = scoped_stats
+        @unscoped_stats = unscoped_stats
+      end
+
+      def method_missing(method, *args)
+        unscoped_stats.send(method, *args)
+        scoped_stats.send(method, *args)
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/stats_engine/gc_profiler.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# -*- coding: utf-8 -*-
+module Mmtrix
+  module Agent
+    class StatsEngine
+      module GCProfiler
+        GCSnapshot = Struct.new(:gc_time_s, :gc_call_count)
+
+        def self.init
+          return @profiler if @initialized
+          @profiler = if RailsBenchProfiler.enabled?
+            RailsBenchProfiler.new
+          elsif CoreGCProfiler.enabled?
+            CoreGCProfiler.new
+          end
+          @initialized = true
+          @profiler
+        end
+
+        def self.reset
+          @profiler    = nil
+          @initialized = nil
+        end
+
+        def self.take_snapshot
+          init
+          if @profiler
+            GCSnapshot.new(@profiler.call_time_s, @profiler.call_count)
+          else
+            nil
+          end
+        end
+
+        def self.record_delta(start_snapshot, end_snapshot)
+          if @profiler && start_snapshot && end_snapshot
+            elapsed_gc_time_s = end_snapshot.gc_time_s - start_snapshot.gc_time_s
+            num_calls         = end_snapshot.gc_call_count - start_snapshot.gc_call_count
+            record_gc_metric(num_calls, elapsed_gc_time_s)
+
+            @profiler.reset
+            elapsed_gc_time_s
+          end
+        end
+
+        def self.record_gc_metric(call_count, elapsed) #THREAD_LOCAL_ACCESS
+          Mmtrix::Agent.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(gc_metric_name, GC_ROLLUP) do |stats|
+            stats.call_count           += call_count
+            stats.total_call_time      += elapsed
+            stats.total_exclusive_time += elapsed
+          end
+        end
+
+        GC_ROLLUP = 'GC/Transaction/all'.freeze
+        GC_OTHER  = 'GC/Transaction/allOther'.freeze
+        GC_WEB    = 'GC/Transaction/allWeb'.freeze
+
+        def self.gc_metric_name
+          if Mmtrix::Agent::Transaction.recording_web_transaction?
+            GC_WEB
+          else
+            GC_OTHER
+          end
+        end
+
+        class RailsBenchProfiler
+          def self.enabled?
+            ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
+          end
+
+          def call_time_s
+            ::GC.time.to_f / 1_000_000 # this value is reported in us, so convert to s
+          end
+
+          def call_count
+            ::GC.collections
+          end
+
+          def reset
+            ::GC.clear_stats
+          end
+        end
+
+        class CoreGCProfiler
+          def self.enabled?
+            Mmtrix::LanguageSupport.gc_profiler_enabled?
+          end
+
+          def call_time_s
+            Mmtrix::Agent.instance.monotonic_gc_profiler.total_time_s
+          end
+
+          def call_count
+            ::GC.count
+          end
+
+          # When using GC::Profiler, it's important to periodically call
+          # GC::Profiler.clear in order to avoid unbounded growth in the number
+          # of GC recordds that are stored. However, we actually do this
+          # internally within MonotonicGCProfiler on calls to #total_time_s,
+          # so the reset here is a no-op.
+          def reset; end
+        end
+      end
+    end
+  end
+end