oneapm_rpm 1.1.2 → 1.1.3

data/lib/one_apm/manager.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+
+require 'one_apm/probe'
+
+require 'one_apm/support/collection_helper'
+require 'one_apm/support/timer_lib'
+require 'one_apm/support/json_wrapper'
+require 'one_apm/support/chained_call'
+require 'one_apm/support/rules_engine'
+require 'one_apm/support/http_clients/uri_util'
+require 'one_apm/support/system_info'
+
+require 'one_apm/metrics/metric_spec'
+require 'one_apm/metrics/metric_data'
+require 'one_apm/metrics/stats'
+
+require 'one_apm/errors/noticed_error'
+require 'one_apm/errors/agent_errors'
+
+require 'one_apm/agent'
+require 'one_apm/agent/cross_app/cross_app_monitor'
+require 'one_apm/support/method_tracer'
+require 'one_apm/support/event/worker_loop'
+require 'one_apm/support/event/event_loop'
+require 'one_apm/transaction/transaction_sample'
+
+require 'one_apm/collector/containers/stats_engine'
+require 'one_apm/collector/containers/transaction_sampler'
+require 'one_apm/collector/containers/sql_sampler'
+require 'one_apm/collector/containers/error_collector'
+
+require 'one_apm/agent/busy_calculator'
+require 'one_apm/agent/database'
+require 'one_apm/support/forked_process_channel'
+
+require 'one_apm/configuration'
+
+require 'one_apm/agent/sampler'
+require 'one_apm/agent/samplers/cpu_sampler'
+require 'one_apm/agent/samplers/memory_sampler'
+require 'one_apm/agent/samplers/object_sampler'
+require 'one_apm/agent/samplers/delayed_job_sampler'
+require 'one_apm/agent/samplers/vm_sampler'
+
+module OneApm
+  module Manager
+    extend self
+
+    @agent = nil
+
+    def agent
+      return @agent if @agent
+      OneApm::Manager.logger.warn("Agent unavailable as it hasn't been started.")
+      OneApm::Manager.logger.warn(caller.join("\n"))
+      nil
+    end
+
+    def agent=(new_agent)
+      @agent = new_agent
+    end
+
+    def start(options = {})
+      raise "Options must be a hash" unless Hash === options
+      OneApm::Support::ForkedProcessChannel.listener.start if options[:start_channel_listener]
+      OneApm::Probe.init({:agent_enabled => true, :sync_startup => true}.merge(options))
+    end
+
+    alias_method :manual_start, :start
+
+    def shutdown(options={})
+      agent.shutdown(options) if agent
+    end
+
+    def restart
+      shutdown
+      agent.harvest_samplers.clear
+      agent.agent_variable_set(:@connect_state, :pending)
+      agent.agent_variable_set(:@worker_thread, nil)
+      agent.harvester.agent_variable_set(:@starting_pid, nil)
+      OneApm::Probe.init({:agent_enabled => true, :sync_startup => true})
+    end
+
+    def logger
+      @logger || OneApm::Logger::StartupLogger.instance
+    end
+
+    def logger=(log)
+      @logger = log
+    end
+
+    def config
+      @config ||= OneApm::Configuration::Manager.new
+    end
+
+    def reset_config
+      @config.reset_to_defaults
+    end
+
+    def revert_to_default_configuration
+      @config.remove_config_type(:manual)
+      @config.remove_config_type(:server)
+    end
+
+    def after_fork(options = {})
+      agent.after_fork(options)
+    end
+
+    def record_metric(metric_name, value)
+      value_to_store = value
+      value_to_store = OneApm::Metrics::Stats.create_from_hash(value) if value.is_a?(Hash)
+      agent.stats_engine.tl_record_unscoped_metrics(metric_name, value_to_store)
+    end
+
+    def increment_metric(metric_name, amount = 1)
+      agent.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
+        stats.increment_count(amount)
+      end
+    end
+
+    def drop_buffered_data
+      agent.drop_buffered_data
+    end
+
+    def add_instrumentation(file_pattern)
+      OneApm::Probe.instance.add_instrumentation file_pattern
+    end
+
+    def set_sql_obfuscator(type = :replace, &block)
+      OneApm::Agent::Database.set_sql_obfuscator(type, &block)
+    end
+
+    def disable_sql_recording
+      state = agent.set_record_sql(false)
+      begin
+        yield
+      ensure
+        agent.set_record_sql(state)
+      end
+    end
+
+    def disable_transaction_tracing
+      state = agent.set_record_tt(false)
+      begin
+        yield
+      ensure
+        agent.set_record_tt(state)
+      end
+    end
+
+    def ignore_transaction
+      txn = OneApm::Transaction.tl_current
+      txn.ignore! if txn
+    end
+
+    def ignore_apdex
+      txn = OneApm::Transaction.tl_current
+      txn.ignore_apdex! if txn
+    end
+
+    def ignore_enduser
+      txn = OneApm::Transaction.tl_current
+      txn.ignore_enduser! if txn
+    end
+
+    def disable_all_tracing
+      agent.push_trace_execution_flag(false)
+      yield
+    ensure
+      agent.pop_trace_execution_flag
+    end
+
+    def record_custom_event(event_type, event_attrs)
+      if agent && OneApm::Manager.config[:'custom_insights_events.enabled']
+        agent.custom_event_aggregator.record(event_type, event_attrs)
+      end
+      nil
+    end
+
+    def tl_is_execution_traced?
+      OneApm::TransactionState.tl_get.is_execution_traced?
+    end
+
+    def tl_is_transaction_traced?
+      OneApm::TransactionState.tl_get.is_transaction_traced?
+    end
+
+    def tl_is_sql_recorded?
+      OneApm::TransactionState.tl_get.is_sql_recorded?
+    end
+
+    def ignore_error_filter(&block)
+      if block
+        OneApm::Collector::ErrorCollector.ignore_error_filter = block
+      else
+        OneApm::Collector::ErrorCollector.ignore_error_filter
+      end
+    end
+
+    def notice_error(exception, options = {})
+      Transaction.notice_error(exception, options)
+      nil
+    end
+
+    def notice_sql(sql, metric, config, elapsed_time, state, &explainer)
+      agent.transaction_sampler.notice_sql(sql, config, elapsed_time, state, &explainer)
+      agent.sql_sampler.notice_sql(sql, metric, config, elapsed_time, state, &explainer)
+    end
+
+    def add_custom_parameters(params)
+      if params.is_a? Hash
+        txn = Transaction.tl_current
+        txn.add_custom_parameters(params) if txn
+      else
+        ::OneApm::Manager.logger.warn("Bad argument passed to #add_custom_parameters. Expected Hash but got #{params.class}")
+      end
+    end
+
+    def set_transaction_name(name, options={})
+      Transaction.set_overriding_transaction_name(name, options[:category])
+    end
+
+    def get_transaction_name
+      txn = Transaction.tl_current
+      if txn
+        txn.best_name.sub(Regexp.new("\\A#{Regexp.escape(OneApm::TransactionNamer.prefix_for_category(txn))}"), '')
+      end
+    end
+
+    def subscribe(event_type, &handler)
+      agent.events.subscribe( event_type, &handler )
+    end
+
+    def notify(event_type, *args)
+      agent.events.notify( event_type, *args )
+    rescue
+      OneApm::Manager.logger.debug "Ignoring exception during %p event notification" % [event_type]
+    end
+
+    def browser_timing_header
+      agent.javascript_instrumentor.browser_timing_header
+    end
+
+    def require_test_helper
+      path = File.join(__FILE__, '..', '..', '..', 'test', 'agent_helper')
+      require File.expand_path(path)
+    end
+
+  end
+end

data/lib/one_apm/metrics/metric_spec.rb

@@ -45,7 +45,7 @@ module OneApm
     # return a new metric spec if the given regex
     # matches the name or scope.
     def sub(pattern, replacement, apply_to_scope = true)
-      ::OneApm::Agent.logger.warn("The sub method on metric specs is deprecated") rescue nil
+      OneApm::Manager.logger.warn("The sub method on metric specs is deprecated") rescue nil
       return nil if name !~ pattern &&
        (!apply_to_scope || scope.nil? || scope !~ pattern)
       new_name = name.sub(pattern, replacement)[LENGTH_RANGE]

data/lib/one_apm/metrics/stats.rb

@@ -145,7 +145,7 @@ module OneApm
           @min_call_time = apdex_t
           @max_call_time = apdex_t
         else
-          ::OneApm::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+          OneApm::Manager.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
         end
       end
 

data/lib/one_apm/probe.rb

@@ -9,7 +9,7 @@ require 'one_apm/probe/framework_loader'
 require 'one_apm/probe/instrumentation'
 require 'one_apm/probe/instance_methods'
 
-require 'one_apm/agent'
+require 'one_apm/manager'
 
 module OneApm
   class Probe; end

data/lib/one_apm/probe/framework_loader.rb

@@ -13,10 +13,10 @@ module OneApm
       end
 
       def new_instance
-        if Agent.config[:framework] == :test
+        if OneApm::Manager.config[:framework] == :test
           load_test_framework
         else
-          load_framework_class(Agent.config[:framework]).new(local_env)
+          load_framework_class(Manager.config[:framework]).new(local_env)
         end
       end
 

data/lib/one_apm/probe/instance_methods.rb

@@ -14,19 +14,19 @@ module OneApm
       def init_plugin(options = {})
         env = options[:env] || self.env
 
-        Agent.logger.info("Starting the OneApm agent in #{env.inspect} environment.")
+        OneApm::Manager.logger.info("Starting the OneAPM Agent (#{OneApm::VERSION::STRING}) in #{env.inspect} environment.")
 
         configure_agent(env, options)
 
         # Be sure to only create once! RUBY-1020
-        if ::OneApm::Agent.logger.is_startup_logger?
-          ::OneApm::Agent.logger = OneApm::Agent::AgentLogger.new(root, options.delete(:log))
+        if OneApm::Manager.logger.is_startup_logger?
+          OneApm::Manager.logger = OneApm::Logger::AgentLogger.new(root, options.delete(:log))
         end
 
         # Merge the stringified options into the config as overrides:
         environment_name = options.delete(:env) and self.env = environment_name
 
-        OneApm::Agent::PipeChannelManager.listener.start if options.delete(:start_channel_listener)
+        OneApm::Support::ForkedProcessChannel.listener.start if options.delete(:start_channel_listener)
 
         # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
         # methods in the module methods.
@@ -36,13 +36,13 @@ module OneApm
         init_config(options)
 
         # initialize agent
-        OneApm::Agent.instance = OneApm::Agent::Agent.instance
-        OneApm::Agent.instance.start_service_if_needed
+        OneApm::Manager.agent = OneApm::Agent::Agent.instance
+        OneApm::Manager.agent.start_service
 
-        if Agent.config[:agent_enabled] && !OneApm::Agent.instance.started?
+        if OneApm::Manager.config[:agent_enabled] && !OneApm::Manager.agent.started?
           start_agent
           install_instrumentation
-        elsif !Agent.config[:agent_enabled]
+        elsif !Manager.config[:agent_enabled]
           install_shim
         else
           detect_dependencies
@@ -51,36 +51,36 @@ module OneApm
 
       def configure_agent(env, options)
         manual = OneApm::Configuration::ManualSource.new(options)
-        Agent.config.replace_or_add_config(manual)
+        OneApm::Manager.config.replace_or_add_config(manual)
 
-        config_file_path = @config_file_override || Agent.config[:config_path]
-        Agent.config.replace_or_add_config(OneApm::Configuration::YamlSource.new(config_file_path, env))
+        config_file_path = @config_file_override || OneApm::Manager.config[:config_path]
+        OneApm::Manager.config.replace_or_add_config(OneApm::Configuration::YamlSource.new(config_file_path, env))
 
-        if Agent.config[:high_security]
-          Agent.logger.info("Installing high security configuration based on local configuration")
-          Agent.config.replace_or_add_config(OneApm::Configuration::HighSecuritySource.new(Agent.config))
+        if OneApm::Manager.config[:high_security]
+          OneApm::Manager.logger.info("Installing high security configuration based on local configuration")
+          OneApm::Manager.config.replace_or_add_config(OneApm::Configuration::HighSecuritySource.new(Manager.config))
         end
       end
 
       # Install the real agent into the Agent module, and issue the start command.
       def start_agent
-        OneApm::Agent.instance.start
+        OneApm::Manager.agent.start
       end
 
       def app
-        Agent.config[:framework]
+        OneApm::Manager.config[:framework]
       end
 
       def framework
-        Agent.config[:framework]
+        OneApm::Manager.config[:framework]
       end
 
       def settings
-        OneApm::Agent.config.to_collector_hash
+        OneApm::Manager.config.to_collector_hash
       end
 
       def dispatcher
-        OneApm::Agent.config[:dispatcher]
+        OneApm::Manager.config[:dispatcher]
       end
 
       def oneapm_root

data/lib/one_apm/probe/instrumentation.rb

@@ -19,7 +19,7 @@ module OneApm
           load_instrumentation_files inst_file
         end
         detect_dependencies
-        OneApm::Agent.logger.info "Finished instrumentation"
+        OneApm::Manager.logger.info "Finished instrumentation"
       end
 
       def load_instrumentation_files pattern
@@ -34,16 +34,16 @@ module OneApm
       def require_instrumentation file
         require file
       rescue => e
-        ::OneApm::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+        OneApm::Manager.logger.warn "Error loading instrumentation file '#{file}':", e
       end
 
       def install_shim
         # Once we install instrumentation, you can't undo that by installing the shim.
         if @instrumented
-          OneApm::Agent.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
-          OneApm::Agent.logger.error caller.join("\n")
+          OneApm::Manager.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
+          OneApm::Manager.logger.error caller.join("\n")
         else
-          OneApm::Agent.instance = OneApm::Agent::ShimAgent.instance
+          OneApm::Manager.agent = OneApm::Agent::ShimAgent.instance
         end
       end
 

data/lib/one_apm/rack/browser_monitoring.rb

@@ -16,7 +16,7 @@ module OneApm::Rack
     def traced_call(env)
       result = @app.call(env)   # [status, headers, response]
 
-      js_to_inject = OneApm::Agent.browser_timing_header
+      js_to_inject = OneApm::Manager.browser_timing_header
       if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
         response_string = autoinstrument_source(result[2], result[1], js_to_inject)
 
@@ -33,7 +33,7 @@ module OneApm::Rack
     end
 
     def should_instrument?(env, status, headers)
-      OneApm::Agent.config[:'browser_monitoring.auto_instrument'] &&
+      OneApm::Manager.config[:'browser_monitoring.auto_instrument'] &&
         status == 200 &&
         !env[ALREADY_INSTRUMENTED_KEY] &&
         is_html?(headers) &&
@@ -80,12 +80,12 @@ module OneApm::Rack
             js_to_inject <<
             source[insertion_index..-1]
         else
-          OneApm::Agent.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
+          OneApm::Manager.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
         end
       else
         msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
-        OneApm::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
-        OneApm::Agent.logger.debug(msg)
+        OneApm::Manager.logger.log_once(:warn, :rum_insertion_failure, msg)
+        OneApm::Manager.logger.debug(msg)
       end
 
       if headers['Content-Length']
@@ -94,7 +94,7 @@ module OneApm::Rack
 
       source
     rescue => e
-      OneApm::Agent.logger.debug "Skipping RUM instrumentation on exception.", e
+      OneApm::Manager.logger.debug "Skipping RUM instrumentation on exception.", e
       nil
     end