mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/transaction_sampler.rb

@@ -0,0 +1,317 @@
+# 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 'mmtrix/agent/transaction_sample_builder'
+require 'mmtrix/agent/transaction/developer_mode_sample_buffer'
+require 'mmtrix/agent/transaction/slowest_sample_buffer'
+require 'mmtrix/agent/transaction/synthetics_sample_buffer'
+require 'mmtrix/agent/transaction/xray_sample_buffer'
+
+module Mmtrix
+  module Agent
+
+    # This class contains the logic for recording and storing transaction
+    # traces (sometimes referred to as 'transaction samples').
+    #
+    # A transaction trace is a detailed timeline of the events that happened
+    # during the processing of a single transaction, including database calls,
+    # template rendering calls, and other instrumented method calls.
+    #
+    # @api public
+    class TransactionSampler
+      attr_reader :last_sample, :dev_mode_sample_buffer, :xray_sample_buffer
+
+      def initialize
+        @dev_mode_sample_buffer = Mmtrix::Agent::Transaction::DeveloperModeSampleBuffer.new
+        @xray_sample_buffer = Mmtrix::Agent::Transaction::XraySampleBuffer.new
+
+        @sample_buffers = []
+        @sample_buffers << @dev_mode_sample_buffer
+        @sample_buffers << @xray_sample_buffer
+        @sample_buffers << Mmtrix::Agent::Transaction::SlowestSampleBuffer.new
+        @sample_buffers << Mmtrix::Agent::Transaction::SyntheticsSampleBuffer.new
+
+        # This lock is used to synchronize access to the @last_sample
+        # and related variables. It can become necessary on JRuby or
+        # any 'honest-to-god'-multithreaded system
+        @samples_lock = Mutex.new
+
+        Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
+          if enabled
+            threshold = Agent.config[:'transaction_tracer.transaction_threshold']
+            ::Mmtrix::Agent.logger.debug "Transaction tracing threshold is #{threshold} seconds."
+          else
+            ::Mmtrix::Agent.logger.debug "Transaction traces will not be sent to the Mmtrix service."
+          end
+        end
+
+        Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
+          if config == 'raw'
+            ::Mmtrix::Agent.logger.warn("Agent is configured to send raw SQL to the service")
+          end
+        end
+      end
+
+      def enabled?
+        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
+      end
+
+      def on_start_transaction(state, start_time)
+        if enabled?
+          start_builder(state, start_time.to_f)
+        end
+      end
+
+      # This delegates to the builder to create a new open transaction node
+      # for the frame, beginning at the optionally specified time.
+      #
+      # Note that in developer mode, this captures a stacktrace for
+      # the beginning of each node, which can be fairly slow
+      def notice_push_frame(state, time=Time.now)
+        builder = state.transaction_sample_builder
+        return unless builder
+
+        node = builder.trace_entry(time.to_f)
+        if @dev_mode_sample_buffer
+          @dev_mode_sample_buffer.visit_node(node)
+        end
+        node
+      end
+
+      # Informs the transaction sample builder about the end of a traced frame
+      def notice_pop_frame(state, frame, time = Time.now)
+        builder = state.transaction_sample_builder
+        return unless builder
+        raise "finished already???" if builder.sample.finished
+        builder.trace_exit(frame, time.to_f)
+      end
+
+      # This is called when we are done with the transaction.  We've
+      # unwound the stack to the top level. It also clears the
+      # transaction sample builder so that it won't continue to have
+      # frames appended to it.
+      #
+      # It sets various instance variables to the finished sample,
+      # depending on which settings are active. See `store_sample`
+      def on_finishing_transaction(state, txn, time=Time.now)
+        last_builder = state.transaction_sample_builder
+        return unless last_builder && enabled?
+
+        state.transaction_sample_builder = nil
+        return if txn.ignore_trace?
+
+        last_builder.finish_trace(time.to_f)
+
+        last_sample = last_builder.sample
+        last_sample.transaction_name = txn.best_name
+        last_sample.uri = txn.request_path
+        last_sample.guid = txn.guid
+        last_sample.attributes = txn.attributes
+
+        @samples_lock.synchronize do
+          @last_sample = last_sample
+          store_sample(@last_sample)
+          @last_sample
+        end
+      end
+
+      def store_sample(sample)
+        @sample_buffers.each do |sample_buffer|
+          sample_buffer.store(sample)
+        end
+      end
+
+      MAX_DATA_LENGTH = 16384
+      # This method is used to record metadata into the currently
+      # active node like a sql query, memcache key, or Net::HTTP uri
+      #
+      # duration is seconds, float value.
+      def notice_extra_data(builder, message, duration, key)
+        return unless builder
+        node = builder.current_node
+        if node
+          if key == :sql
+            sql = node[:sql]
+            if(sql && !sql.empty?)
+              sql = self.class.truncate_message(sql << "\n#{message}") if sql.length <= MAX_DATA_LENGTH
+            else
+              # message is expected to have been pre-truncated by notice_sql
+              node[:sql] = message
+            end
+          else
+            node[key] = self.class.truncate_message(message)
+          end
+          append_backtrace(node, duration)
+        end
+      end
+
+      private :notice_extra_data
+
+      # Truncates the message to `MAX_DATA_LENGTH` if needed, and
+      # appends an ellipsis because it makes the trucation clearer in
+      # the UI
+      def self.truncate_message(message)
+        if message.length > (MAX_DATA_LENGTH - 4)
+          message.slice!(MAX_DATA_LENGTH - 4..message.length)
+          message << "..."
+        else
+          message
+        end
+      end
+
+      # Appends a backtrace to a node if that node took longer
+      # than the specified duration
+      def append_backtrace(node, duration)
+        if duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
+          node[:backtrace] = caller.join("\n")
+        end
+      end
+
+      # Attaches an SQL query on the current transaction trace node.
+      #
+      # 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 config [Object] 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, config, duration, state=nil, explainer=nil) #THREAD_LOCAL_ACCESS sometimes
+        # some statements (particularly INSERTS with large BLOBS
+        # may be very large; we should trim them to a maximum usable length
+        state ||= TransactionState.tl_get
+        builder = state.transaction_sample_builder
+        if state.is_sql_recorded?
+          statement = build_database_statement(sql, config, explainer)
+          notice_extra_data(builder, statement, duration, :sql)
+        end
+      end
+
+      def build_database_statement(sql, config, explainer)
+        statement = Database::Statement.new(Database.capture_query(sql))
+        if config
+          statement.adapter = config[:adapter]
+          statement.config = config
+        end
+        statement.explainer = explainer
+
+        statement
+      end
+
+      # Attaches an additional non-SQL query parameter to the current
+      # transaction trace node.
+      #
+      # This may be used for recording a query against a key-value store like
+      # memcached or redis.
+      #
+      # This method should be used only by gem authors wishing to extend
+      # the Ruby agent to instrument uninstrumented key-value stores - it should
+      # generally not be called directly from application code.
+      #
+      # @param key [String] the name of the key that was queried
+      # @param duration [Float] number of seconds the query took to execute
+      #
+      # @api public
+      # @deprecated Use {Datastores.notice_statement} instead.
+      #
+      def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
+        notice_extra_data(builder, key, duration, :key)
+      end
+
+      def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
+        notice_extra_data(builder, statement, duration, :statement)
+      end
+
+      # Set parameters on the current node.
+      def add_node_parameters(params) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
+        return unless builder
+        params.each { |k,v| builder.current_node[k] = v }
+      end
+
+      # Gather transaction traces that we'd like to transmit to the server.
+      def harvest!
+        return [] unless enabled?
+
+        samples = @samples_lock.synchronize do
+          @last_sample = nil
+          harvest_from_sample_buffers
+        end
+        prepare_samples(samples)
+      end
+
+      def prepare_samples(samples)
+        samples.select do |sample|
+          begin
+            sample.prepare_to_send!
+          rescue => e
+            Mmtrix::Agent.logger.error("Failed to prepare transaction trace. Error: ", e)
+            false
+          else
+            true
+          end
+        end
+      end
+
+      def merge!(previous)
+        @samples_lock.synchronize do
+          @sample_buffers.each do |buffer|
+            buffer.store_previous(previous)
+          end
+        end
+      end
+
+      def count
+        @samples_lock.synchronize do
+          samples = @sample_buffers.inject([]) { |all, b| all.concat(b.samples) }
+          samples.uniq.size
+        end
+      end
+
+      def harvest_from_sample_buffers
+        # map + flatten hit mocking issues calling to_ary on 1.9.2.  We only
+        # want a single level flatten anyway, but, as you probably already
+        # know, Ruby 1.8.6 :/
+        result = []
+        @sample_buffers.each { |buffer| result.concat(buffer.harvest_samples) }
+        result.uniq
+      end
+
+      # reset samples without rebooting the web server (used by dev mode)
+      def reset!
+        @samples_lock.synchronize do
+          @last_sample = nil
+          @sample_buffers.each { |sample_buffer| sample_buffer.reset! }
+        end
+      end
+
+      # Checks to see if the transaction sampler is disabled, if
+      # transaction trace recording is disabled by a thread local, or
+      # if execution is untraced - if so it clears the transaction
+      # sample builder from the thread local, otherwise it generates a
+      # new transaction sample builder with the stated time as a
+      # starting point and saves it in the thread local variable
+      def start_builder(state, time=nil)
+        if !enabled? || !state.is_transaction_traced? || !state.is_execution_traced?
+          state.transaction_sample_builder = nil
+        else
+          state.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
+        end
+      end
+
+      # The current thread-local transaction sample builder
+      def tl_builder
+        TransactionState.tl_get.transaction_sample_builder
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/transaction_state.rb

@@ -0,0 +1,153 @@
+# 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 'mmtrix/agent/traced_method_stack'
+
+module Mmtrix
+  module Agent
+
+    # 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[:mmtrix_transaction_state]
+
+        if state.nil?
+          state = TransactionState.new
+          thread[:mmtrix_transaction_state] = state
+        end
+
+        state
+      end
+
+      def self.tl_clear_for_testing
+        Thread.current[:mmtrix_transaction_state] = nil
+      end
+
+      def initialize
+        @untraced = []
+        @traced_method_stack = 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 Mmtrix::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 Mmtrix::StatsEngine::Transactions
+      # Should not be nil--this class manages its initialization and resetting
+      attr_reader :traced_method_stack
+    end
+  end
+end

data/lib/mmtrix/agent/transaction_timings.rb

@@ -0,0 +1,57 @@
+# 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 TransactionTimings
+
+      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
+
+      attr_reader :transaction_name,
+                  :start_time_in_seconds, :queue_time_in_seconds
+
+      def transaction_name_or_unknown
+        transaction_name || ::Mmtrix::Agent::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
+end

data/lib/mmtrix/agent/utilization_data.rb

@@ -0,0 +1,64 @@
+# 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 'mmtrix/agent/aws_info'
+
+module Mmtrix
+  module Agent
+    class UtilizationData
+      METADATA_VERSION = 1
+
+      def hostname
+        Mmtrix::Agent::Hostname.get
+      end
+
+      def container_id
+        ::Mmtrix::Agent::SystemInfo.docker_container_id
+      end
+
+      def cpu_count
+        ::Mmtrix::Agent::SystemInfo.clear_processor_info
+        ::Mmtrix::Agent::SystemInfo.num_logical_processors
+      end
+
+      def ram_in_mib
+        ::Mmtrix::Agent::SystemInfo.ram_in_mib
+      end
+
+      def to_collector_hash
+        result = {
+          :metadata_version => METADATA_VERSION,
+          :logical_processors => cpu_count,
+          :total_ram_mib => ram_in_mib,
+          :hostname => hostname
+        }
+
+        append_aws_info(result)
+        append_docker_info(result)
+
+        result
+      end
+
+      def append_aws_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_aws']
+
+        aws_info = AWSInfo.new
+
+        if aws_info.loaded?
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:aws] = aws_info.to_collector_hash
+        end
+      end
+
+      def append_docker_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_docker']
+
+        if docker_container_id = container_id
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:docker] = {:id => docker_container_id}
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/vm/jruby_vm.rb

@@ -0,0 +1,40 @@
+# 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 'thread'
+require 'mmtrix/agent/vm/snapshot'
+
+module Mmtrix
+  module Agent
+    module VM
+      class JRubyVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          if supports?(:gc_runs)
+            gc_stats = GC.stat
+            snap.gc_runs = gc_stats[:count]
+          end
+
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs
+            RUBY_VERSION >= "1.9.2"
+          when :thread_count
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/vm/monotonic_gc_profiler.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# The GC::Profiler class available on MRI has to be reset periodically to avoid
+# memory "leaking" in the underlying implementation. However, it's a major
+# bummer for how we want to gather those statistics.
+#
+# This class comes to the rescue. It relies on being the only party to reset
+# the underlying GC::Profiler, but otherwise gives us a steadily increasing
+# total time.
+
+module Mmtrix
+  module Agent
+    module VM
+      class MonotonicGCProfiler
+        def initialize
+          @total_time_s = 0
+          @lock         = Mutex.new
+        end
+
+        def total_time_s
+          if Mmtrix::LanguageSupport.gc_profiler_enabled?
+            # There's a race here if the next two lines don't execute as an atomic
+            # unit - we may end up double-counting some GC time in that scenario.
+            # Locking around them guarantees atomicity of the read/increment/reset
+            # sequence.
+            @lock.synchronize do
+              # The Ruby 1.9.x docs claim that GC::Profiler.total_time returns
+              # a value in milliseconds. They are incorrect - both 1.9.x and 2.x
+              # return values in seconds.
+              @total_time_s += ::GC::Profiler.total_time
+              ::GC::Profiler.clear
+            end
+          else
+            Mmtrix::Agent.logger.log_once(:warn, :gc_profiler_disabled,
+              "Tried to measure GC time, but GC::Profiler was not enabled.")
+          end
+
+          @total_time_s
+        end
+      end
+    end
+  end
+end