oneapm_rpm 1.1.2 → 1.1.3

data/lib/one_apm/agent/busy_calculator.rb

@@ -4,25 +4,13 @@ require 'one_apm/transaction/transaction_state'
 
 module OneApm
   module Agent
-    # This module supports calculation of actual time spent processing requests over the course of
-    # one harvest period.  It's similar to what you would get if you just added up all the
-    # execution times of controller calls, however that will be inaccurate when requests
-    # span the minute boundaries.  This module manages accounting of requests not yet
-    # completed.
-    #
-    # Calls are re-entrant.  All start calls must be paired with finish
-    # calls, or a reset call.
     module BusyCalculator
 
       extend self
 
-      # For testability, add accessors:
       attr_reader :harvest_start, :accumulator
 
-      # sets up busy calculations based on the start and end of
-      # transactions - used for a rough estimate of what percentage of
-      # wall clock time is spent processing requests
-      def dispatcher_start(time) #THREAD_LOCAL_ACCESS
+      def dispatcher_start(time)
         state = TransactionState.tl_get
         state.busy_entries ||= 0
         callers = state.busy_entries += 1
@@ -32,38 +20,29 @@ module OneApm
         end
       end
 
-      # called when a transaction finishes, to add time to the
-      # instance variable accumulator. this is harvested when we send
-      # data to the server
-      def dispatcher_finish(end_time = nil) #THREAD_LOCAL_ACCESS
+      def dispatcher_finish(end_time = nil)
         state = TransactionState.tl_get
-        # If #dispatcher_start hasn't been called at least once, abort early
         return unless state.busy_entries
 
         end_time ||= time_now
         callers = state.busy_entries -= 1
 
-        # Ignore nested calls
         return if callers > 0
 
         @lock.synchronize do
           if @entrypoint_stack.empty?
-            ::OneApm::Agent.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
+            OneApm::Manager.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
           else
             @accumulator += (end_time - @entrypoint_stack.pop).to_f
           end
         end
       end
 
-      # this returns the size of the entry point stack, which
-      # determines how many transactions are running
       def busy_count
         @entrypoint_stack.size
       end
 
-      # Reset the state of the information accumulated by all threads,
-      # but only reset the recursion counter for this thread.
-      def reset #THREAD_LOCAL_ACCESS
+      def reset
         @entrypoint_stack = []
         TransactionState.tl_get.busy_entries = 0
         @lock ||= Mutex.new
@@ -71,8 +50,6 @@ module OneApm
         @harvest_start = time_now
       end
 
-
-      # Called before uploading to to the server to collect current busy stats.
       def harvest_busy
         busy = 0
         t0 = time_now
@@ -80,8 +57,6 @@ module OneApm
           busy = accumulator
           @accumulator = 0
 
-          # Walk through the stack and capture all times up to
-          # now for entrypoints
           @entrypoint_stack.size.times do |frame|
             busy += (t0 - @entrypoint_stack[frame]).to_f
             @entrypoint_stack[frame] = t0
@@ -89,22 +64,21 @@ module OneApm
 
         end
 
-        busy = 0.0 if busy < 0.0 # don't go below 0%
+        busy = 0.0 if busy < 0.0
 
         time_window = (t0 - harvest_start).to_f
-        time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+        time_window = 1.0 if time_window == 0.0
 
         busy = busy / time_window
 
-        if Agent.config[:report_instance_busy]
-          OneApm::Agent.record_metric('Instance/Busy', busy)
+        if OneApm::Manager.config[:report_instance_busy]
+          OneApm::Manager.record_metric('Instance/Busy', busy)
         end
         @harvest_start = t0
       end
 
       private
 
-      # so we can stub Time.now only for the BusyCalculator in tests
       def time_now
         Time.now
       end

data/lib/one_apm/agent/cross_app/cross_app_monitor.rb

@@ -26,10 +26,10 @@ module OneApm
       #   :before_call will save our cross application request id to the thread
       #   :after_call will write our response headers/metrics and clean up the thread
       def register_event_listeners(events)
-        OneApm::Agent.logger.
+        OneApm::Manager.logger.
           debug("Wiring up Cross Application Tracing to events after finished configuring")
 
-        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
+        events.subscribe(:before_call) do |env|
           if should_process_request(env)
             state = OneApm::TransactionState.tl_get
 
@@ -39,13 +39,13 @@ module OneApm
           end
         end
 
-        events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
+        events.subscribe(:after_call) do |env, (_status_code, headers, _body)|
           state = OneApm::TransactionState.tl_get
 
           insert_response_header(state, env, headers)
         end
 
-        events.subscribe(:notice_error) do |_, options| #THREAD_LOCAL_ACCESS
+        events.subscribe(:notice_error) do |_, options|
           state = OneApm::TransactionState.tl_get
 
           set_error_custom_parameters(state, options)
@@ -116,7 +116,7 @@ module OneApm
         split_id = id.match(/(\d+)#\d+/)
         return false if split_id.nil?
 
-        OneApm::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
+        OneApm::Manager.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
       end
 
       def set_response_headers(state, response_headers, timings, content_length)
@@ -125,7 +125,7 @@ module OneApm
 
       def build_payload(state, timings, content_length)
         payload = [
-          OneApm::Agent.config[:cross_process_id],
+          OneApm::Manager.config[:cross_process_id],
           timings.transaction_name,
           timings.queue_time_in_seconds.to_f,
           timings.app_time_in_seconds.to_f,
@@ -138,11 +138,11 @@ module OneApm
       def set_transaction_custom_parameters(state)
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        OneApm::Agent.add_custom_parameters(:client_cross_process_id => state.client_cross_app_id) if state.client_cross_app_id
+        OneApm::Manager.add_custom_parameters(:client_cross_process_id => state.client_cross_app_id) if state.client_cross_app_id
 
         referring_guid = client_referring_transaction_guid(state)
         if referring_guid
-          OneApm::Agent.add_custom_parameters(:referring_transaction_guid => referring_guid)
+          OneApm::Manager.add_custom_parameters(:referring_transaction_guid => referring_guid)
         end
       end
 
@@ -152,7 +152,7 @@ module OneApm
 
       def set_metrics(id, timings)
         metric_name = "ClientApplication/#{id}/all"
-        OneApm::Agent.record_metric(metric_name, timings.app_time_in_seconds)
+        OneApm::Manager.record_metric(metric_name, timings.app_time_in_seconds)
       end
 
       def decoded_id(request)
@@ -172,7 +172,7 @@ module OneApm
 
       def path_hash(txn_name, seed)
         rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
-        app_name   = OneApm::Agent.config.app_names.first
+        app_name   = OneApm::Manager.config.app_names.first
         identifier = "#{app_name};#{txn_name}"
         sprintf("%08x", rotated ^ hash_transaction_name(identifier))
       end

data/lib/one_apm/agent/cross_app/cross_app_tracing.rb

@@ -72,10 +72,10 @@ module OneApm
 
         return segment
       rescue => err
-        OneApm::Agent.logger.error "Uncaught exception while tracing HTTP request", err
+        OneApm::Manager.logger.error "Uncaught exception while tracing HTTP request", err
         return nil
       rescue Exception => e
-        OneApm::Agent.logger.debug "Unexpected exception raised while tracing HTTP request", e
+        OneApm::Manager.logger.debug "Unexpected exception raised while tracing HTTP request", e
 
         raise e
       end
@@ -94,7 +94,7 @@ module OneApm
       #
       def finish_trace(state, t0, segment, request, response)
         unless t0
-          OneApm::Agent.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
+          OneApm::Manager.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
           return
         end
 
@@ -127,9 +127,9 @@ module OneApm
           end
         end
       rescue OneApm::Agent::CrossAppTracing::Error => err
-        OneApm::Agent.logger.debug "while cross app tracing", err
+        OneApm::Manager.logger.debug "while cross app tracing", err
       rescue => err
-        OneApm::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
+        OneApm::Manager.logger.error "Uncaught exception while finishing an HTTP request trace", err
       end
 
       # Return +true+ if cross app tracing is enabled in the config.
@@ -140,21 +140,21 @@ module OneApm
       end
 
       def valid_cross_process_id?
-        OneApm::Agent.config[:cross_process_id] && OneApm::Agent.config[:cross_process_id].length > 0
+        OneApm::Manager.config[:cross_process_id] && OneApm::Manager.config[:cross_process_id].length > 0
       end
 
       def valid_encoding_key?
-        OneApm::Agent.config[:encoding_key] && OneApm::Agent.config[:encoding_key].length > 0
+        OneApm::Manager.config[:encoding_key] && OneApm::Manager.config[:encoding_key].length > 0
       end
 
       def cross_application_tracer_enabled?
-        OneApm::Agent.config[:"cross_application_tracer.enabled"]
+        OneApm::Manager.config[:"cross_application_tracer.enabled"]
       end
 
       # Fetcher for the cross app encoding key. Raises a
       # OneApm::Agent::CrossAppTracing::Error if the key isn't configured.
       def cross_app_encoding_key
-        OneApm::Agent.config[:encoding_key] or
+        OneApm::Manager.config[:encoding_key] or
           raise OneApm::Agent::CrossAppTracing::Error, "No encoding_key set."
       end
 
@@ -164,7 +164,7 @@ module OneApm
 
       # Inject the X-Process header into the outgoing +request+.
       def inject_request_headers(state, request)
-        cross_app_id = OneApm::Agent.config[:cross_process_id] or
+        cross_app_id = OneApm::Manager.config[:cross_process_id] or
           raise OneApm::Agent::CrossAppTracing::Error, "no cross app ID configured"
 
         state.is_cross_app_caller = true
@@ -184,7 +184,7 @@ module OneApm
         request[OA_TXN_HEADER] = obfuscator.obfuscate(txn_data)
 
       rescue OneApm::Agent::CrossAppTracing::Error => err
-        OneApm::Agent.logger.debug "Not injecting x-process header", err
+        OneApm::Manager.logger.debug "Not injecting x-process header", err
       end
 
       def add_transaction_trace_parameters(request, response)
@@ -217,7 +217,7 @@ module OneApm
             metrics.concat metrics_for_crossapp_response( request, response )
           rescue => err
             # Fall back to regular metrics if there's a problem with x-process metrics
-            OneApm::Agent.logger.debug "%p while fetching x-process metrics: %s" %
+            OneApm::Manager.logger.debug "%p while fetching x-process metrics: %s" %
               [ err.class, err.message ]
             metrics.concat metrics_for_regular_request( request )
           end
@@ -308,11 +308,11 @@ module OneApm
 
       # Fetch a reference to the stats engine.
       def stats_engine
-        OneApm::Agent.instance.stats_engine
+        OneApm::Manager.agent.stats_engine
       end
 
       def transaction_sampler
-        OneApm::Agent.instance.transaction_sampler
+        OneApm::Manager.agent.transaction_sampler
       end
 
       # Check the given +id+ to ensure it conforms to the format of a cross-application

data/lib/one_apm/agent/database.rb

@@ -6,7 +6,6 @@ require 'one_apm/agent/database/obfuscator'
 require 'one_apm/agent/database/postgres_explain_obfuscator'
 
 module OneApm
-  # columns for a mysql explain plan
   MYSQL_EXPLAIN_COLUMNS = [
                            "Id",
                            "Select Type",
@@ -47,7 +46,7 @@ module OneApm
       end
 
       def record_sql_method(config_section=:transaction_tracer)
-        case Agent.config["#{config_section}.record_sql".to_sym].to_s
+        case OneApm::Manager.config["#{config_section}.record_sql".to_sym].to_s
         when 'off'
           :off
         when 'none'
@@ -69,7 +68,7 @@ module OneApm
 
       def should_collect_explain_plans?(config_section=:transaction_tracer)
         should_record_sql?(config_section) &&
-          Agent.config["#{config_section}.explain_enabled".to_sym]
+          OneApm::Manager.config["#{config_section}.explain_enabled".to_sym]
       end
 
       def get_connection(config, &connector)
@@ -80,26 +79,14 @@ module OneApm
         ConnectionManager.instance.close_connections
       end
 
-      # This takes a connection config hash from ActiveRecord or Sequel and
-      # returns a string describing the associated database adapter
       def adapter_from_config(config)
         if config[:adapter]
           return config[:adapter].to_s
         elsif config[:uri] && config[:uri].to_s =~ /^jdbc:([^:]+):/
-          # This case is for Sequel with the jdbc-mysql, jdbc-postgres, or
-          # jdbc-sqlite3 gems.
           return $1
         end
       end
 
-      # Perform this in the runtime environment of a managed
-      # application, to explain the sql statement executed within a
-      # segment of a transaction sample. Returns an array of
-      # explanations (which is an array rows consisting of an array of
-      # strings for each column returned by the the explain query)
-      # Note this happens only for statements whose execution time
-      # exceeds a threshold (e.g. 500ms) and only within the slowest
-      # transaction in a report period, selected for shipment to OneApm
       def explain_sql(sql, connection_config, &explainer)
         return nil unless sql && connection_config
         statement = sql.split(";\n")[0] # only explain the first
@@ -113,25 +100,25 @@ module OneApm
         return unless is_select?(statement)
 
         if statement[-3,3] == '...'
-          OneApm::Agent.logger.debug('Unable to collect explain plan for truncated query.')
+          OneApm::Manager.logger.debug('Unable to collect explain plan for truncated query.')
           return
         end
 
         if parameterized?(statement)
-          OneApm::Agent.logger.debug('Unable to collect explain plan for parameterized query.')
+          OneApm::Manager.logger.debug('Unable to collect explain plan for parameterized query.')
           return
         end
 
         adapter = adapter_from_config(config)
         if !SUPPORTED_ADAPTERS_FOR_EXPLAIN.include?(adapter)
-          OneApm::Agent.logger.debug("Not collecting explain plan because an unknown connection adapter ('#{adapter}') was used.")
+          OneApm::Manager.logger.debug("Not collecting explain plan because an unknown connection adapter ('#{adapter}') was used.")
           return
         end
 
         handle_exception_in_explain do
           start = Time.now
           plan = explainer.call(config, statement)
-          ::OneApm::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
+          OneApm::Manager.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
           return process_resultset(plan, adapter) if plan
         end
       end
@@ -168,11 +155,6 @@ module OneApm
         [[QUERY_PLAN], values]
       end
 
-      # Sequel returns explain plans as just one big pre-formatted String
-      # In that case, we send a nil headers array, and the single string
-      # wrapped in an array for the values.
-      # Note that we don't use this method for Postgres explain plans, since
-      # they need to be passed through the explain plan obfuscator first.
       def string_explain_plan_results(results)
         [nil, [results]]
       end
@@ -182,15 +164,11 @@ module OneApm
         headers = []
         values  = []
         if results.is_a?(Array)
-          # We're probably using the jdbc-mysql gem for JRuby, which will give
-          # us an array of hashes.
           headers = results.first.keys
           results.each do |row|
             values << headers.map { |h| row[h] }
           end
         else
-          # We're probably using the native mysql driver gem, which will give us
-          # a Mysql::Result object that responds to each_hash
           results.each_hash do |row|
             headers = row.keys
             values << headers.map { |h| row[h] }
@@ -224,7 +202,7 @@ module OneApm
       rescue => e
         begin
           # guarantees no throw from explain_sql
-          ::OneApm::Agent.logger.error("Error getting query plan:", e)
+          OneApm::Manager.logger.error("Error getting query plan:", e)
           nil
         rescue
           # double exception. throw up your hands
@@ -267,10 +245,6 @@ module OneApm
       class ConnectionManager
         include Singleton
 
-        # Returns a cached connection for a given ActiveRecord
-        # configuration - these are stored or reopened as needed, and if
-        # we cannot get one, we ignore it and move on without explaining
-        # the sql
         def get_connection(config, &connector)
           @connections ||= {}
 
@@ -281,12 +255,11 @@ module OneApm
           begin
             @connections[config] = connector.call(config)
           rescue => e
-            ::OneApm::Agent.logger.error("Caught exception trying to get connection to DB for explain.", e)
+            OneApm::Manager.logger.error("Caught exception trying to get connection to DB for explain.", e)
             nil
           end
         end
 
-        # Closes all the connections in the internal connection cache
         def close_connections
           @connections ||= {}
           @connections.values.each do |connection|

data/lib/one_apm/agent/database/active_record_helper.rb

@@ -27,7 +27,7 @@ module OneApm
           end
         end
 
-        def metric_for_sql(sql) #THREAD_LOCAL_ACCESS
+        def metric_for_sql(sql)
           txn = OneApm::Transaction.tl_current
           metric = txn && txn.database_metric_name
           if metric.nil?

data/lib/one_apm/agent/datastores.rb

@@ -6,23 +6,6 @@ module OneApm
   module Agent
     module Datastores
 
-      # Add Datastore tracing to a method. This properly generates the metrics
-      # for OneApm's Datastore features. It does not capture the actual
-      # query content into Transaction Traces. Use wrap if you want to provide
-      # that functionality.
-      #
-      # @param [Class] clazz the class to instrument
-      #
-      # @param [String, Symbol] method_name the name of instance method to
-      # instrument
-      #
-      # @param [String] product name of your datastore for use in metric naming, e.g. "Redis"
-      #
-      # @param [optional,String] operation the name of operation if different
-      # than the instrumented method name
-      #
-      # @api public
-      #
       def self.trace(clazz, method_name, product, operation = method_name)
         clazz.class_eval do
           method_name_without_oneapm = "#{method_name}_without_oneapm"
@@ -47,49 +30,6 @@ module OneApm
         end
       end
 
-      # Wrap a call to a datastore and record OneApm Datastore metrics. This
-      # method can be used when a collection (i.e. table or model name) is
-      # known at runtime to be included in the metric naming. It is intended
-      # for situations that the simpler OneApm::Agent::Datastores.trace can't
-      # properly handle.
-      #
-      # To use this, wrap the datastore operation in the block passed to wrap.
-      #
-      #   OneApm::Agent::Datastores.wrap("FauxDB", "find", "items") do
-      #     FauxDB.find(query)
-      #   end
-      #
-      # @param [String] product the datastore name for use in metric naming,
-      # e.g. "FauxDB"
-      #
-      # @param [String,Symbol] operation the name of operation (e.g. "select"),
-      # often named after the method that's being instrumented.
-      #
-      # @param [optional, String] collection the collection name for use in
-      # statement-level metrics (i.e. table or model name)
-      #
-      # @param [Proc,#call] callback proc or other callable to invoke after
-      # running the datastore block. Receives three arguments: result of the
-      # yield, the most specific (scoped) metric name, and elapsed time of the
-      # call. An example use is attaching SQL to Transaction Traces at the end
-      # of a wrapped datastore call.
-      #
-      #   callback = Proc.new do |result, metrics, elapsed|
-      #     OneApm::Agent::Datastores.notice_sql(query, metrics, elapsed)
-      #   end
-      #
-      #   OneApm::Agent::Datastores.wrap("FauxDB", "find", "items", callback) do
-      #     FauxDB.find(query)
-      #   end
-      #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING SQL!**
-      # OneApm's Transaction Tracing and Slow SQL features will
-      # attempt to apply obfuscation to the passed queries, but it is possible
-      # for a query format to be unsupported and result in exposing user
-      # information embedded within captured queries.
-      #
-      # @api public
-      #
       def self.wrap(product, operation, collection = nil, callback = nil)
         return yield unless operation
 
@@ -108,64 +48,17 @@ module OneApm
         end
       end
 
-      # Wrapper for simplifying attaching SQL queries during a transaction.
-      #
-      # If you are recording non-SQL data, please use the notice_statement
-      # method instead.
-      #
-      #   OneApm::Agent::Datastores.notice_sql(query, metrics, elapsed)
-      #
-      # @param [String] query the SQL text to be captured. Note that depending
-      # on user settings, this string will be run through obfuscation, but
-      # some dialects of SQL (or non-SQL queries) are not guaranteed to be
-      # properly obfuscated by these routines!
-      #
-      # @param [String] scoped_metric The most specific metric relating to this
-      # query. Typically the result of
-      # OneApm::Agent::Datastores::MetricHelper#metrics_for
-      #
-      # @param [Float] elapsed the elapsed time during query execution
-      #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING SQL!**
-      # OneApm's Transaction Tracing and Slow SQL features will
-      # attempt to apply obfuscation to the passed queries, but it is possible
-      # for a query format to be unsupported and result in exposing user
-      # information embedded within captured queries.
-      #
       def self.notice_sql(query, scoped_metric, elapsed)
-        agent = OneApm::Agent.instance
+        agent = OneApm::Manager.agent
         agent.transaction_sampler.notice_sql(query, nil, elapsed)
         agent.sql_sampler.notice_sql(query, scoped_metric, nil, elapsed)
         nil
       end
 
-      # Wrapper for simplifying attaching non-SQL data statements to a
-      # transaction. For instance, Mongo or CQL queries, Memcached or Redis
-      # keys would all be appropriate data to attach as statements.
-      #
-      # Data passed to this method is NOT obfuscated by OneApm, so please
-      # ensure that user information is obfuscated if the agent setting
-      # `transaction_tracer.record_sql` is set to `obfuscated`
-      #
-      #   OneApm::Agent::Datastores.notice_statement("key", elapsed)
-      #
-      # @param [String] statement text of the statement to capture.
-      #
-      # @param [Float] elapsed the elapsed time during query execution
-      #
-      # **NOTE: THERE ARE SECURITY CONCERNS WHEN CAPTURING STATEMENTS!**
-      # This method will properly ignore statements when the user has turned
-      # off capturing queries, but it is not able to obfuscate arbitrary data!
-      # To prevent exposing user information embedded in captured queries,
-      # please ensure all data passed to this method is safe to transmit to
-      # OneApm.
-      #
       def self.notice_statement(statement, elapsed)
-        # Settings may change eventually, but for now we follow the same
-        # capture rules as SQL for non-SQL statements.
         return unless OneApm::Agent::Database.should_record_sql?
 
-        agent = OneApm::Agent.instance
+        agent = OneApm::Manager.agent
         agent.transaction_sampler.notice_nosql_statement(statement, elapsed)
         nil
       end