oneapm_rpm 1.1.2 → 1.1.3

data/lib/one_apm/agent/threading/agent_thread.rb

@@ -6,17 +6,17 @@ module OneApm
       class AgentThread
 
         def self.create(label, &blk)
-          ::OneApm::Agent.logger.debug("Creating OneApm thread: #{label}")
+          OneApm::Manager.logger.debug("Creating OneApm thread: #{label}")
           wrapped_blk = Proc.new do
             begin
               blk.call
             rescue => e
-              ::OneApm::Agent.logger.error("Thread #{label} exited with error", e)
+              OneApm::Manager.logger.error("Thread #{label} exited with error", e)
             rescue Exception => e
-              ::OneApm::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
+              OneApm::Manager.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
               raise
             ensure
-              ::OneApm::Agent.logger.debug("Exiting OneApm thread: #{label}")
+              OneApm::Manager.logger.debug("Exiting OneApm thread: #{label}")
             end
           end
 
@@ -31,7 +31,7 @@ module OneApm
           backing_thread_class.list
         end
 
-        def self.bucket_thread(thread, profile_agent_code) #THREAD_LOCAL_ACCESS
+        def self.bucket_thread(thread, profile_agent_code)
           if thread.key?(:oneapm_label)
             profile_agent_code ? :agent : :ignore
           else
@@ -50,7 +50,7 @@ module OneApm
           begin
             bt = thread.backtrace
           rescue Exception => e
-            ::OneApm::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
+            OneApm::Manager.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
           end
           return nil unless bt
           bt.reject! { |t| t.include?('one_apm') } unless profile_agent_code

data/lib/one_apm/agent/threading/backtrace_service.rb

@@ -24,11 +24,11 @@ module OneApm
 
           @running = false
           @profile_agent_code = false
-          @worker_loop = OneApm::Agent::WorkerLoop.new
+          @worker_loop = OneApm::Support::WorkerLoop.new
 
           # Memoize overhead % to avoid getting stale OR looked up every poll
-          @overhead_percent_threshold = OneApm::Agent.config[:'xray_session.max_profile_overhead']
-          OneApm::Agent.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
+          @overhead_percent_threshold = OneApm::Manager.config[:'xray_session.max_profile_overhead']
+          OneApm::Manager.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
             @overhead_percent_threshold = new_value
           end
 
@@ -45,11 +45,11 @@ module OneApm
 
         def subscribe(transaction_name, command_arguments={})
           if !self.class.is_supported?
-            OneApm::Agent.logger.debug("Backtracing not supported, so not subscribing transaction '#{transaction_name}'")
+            OneApm::Manager.logger.debug("Backtracing not supported, so not subscribing transaction '#{transaction_name}'")
             return
           end
 
-          OneApm::Agent.logger.debug("Backtrace Service subscribing transaction '#{transaction_name}'")
+          OneApm::Manager.logger.debug("Backtrace Service subscribing transaction '#{transaction_name}'")
 
           profile = ThreadProfile.new(command_arguments)
 
@@ -65,7 +65,7 @@ module OneApm
         def unsubscribe(transaction_name)
           return unless self.class.is_supported?
 
-          OneApm::Agent.logger.debug("Backtrace Service unsubscribing transaction '#{transaction_name}'")
+          OneApm::Manager.logger.debug("Backtrace Service unsubscribing transaction '#{transaction_name}'")
           @lock.synchronize do
             @profiles.delete(transaction_name)
             if @profiles.empty?
@@ -188,7 +188,7 @@ module OneApm
             if @buffer[thread].length < MAX_BUFFER_LENGTH
               @buffer[thread] << [timestamp, backtrace]
             else
-              OneApm::Agent.increment_metric('Supportability/XraySessions/DroppedBacktraces')
+              OneApm::Manager.increment_metric('Supportability/XraySessions/DroppedBacktraces')
             end
           end
         end
@@ -242,13 +242,13 @@ module OneApm
         end
 
         def record_polling_time(now, poll_start)
-          OneApm::Agent.record_metric('Supportability/ThreadProfiler/PollingTime', now - poll_start)
+          OneApm::Manager.record_metric('Supportability/ThreadProfiler/PollingTime', now - poll_start)
         end
 
         def record_skew(poll_start)
           if @last_poll
             skew = poll_start - @last_poll - worker_loop.period
-            OneApm::Agent.record_metric('Supportability/ThreadProfiler/Skew', skew)
+            OneApm::Manager.record_metric('Supportability/ThreadProfiler/Skew', skew)
           end
           @last_poll = poll_start
         end

data/lib/one_apm/agent/threading/thread_profile.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'set'
-require 'one_apm/agent/event/worker_loop'
+require 'one_apm/support/event/worker_loop'
 require 'one_apm/agent/threading/backtrace_node'
 
 # Data structure for representing a thread profile
@@ -84,10 +84,10 @@ module OneApm
           end
         end
 
-        def convert_N_trace_nodes_to_arrays(count_to_keep) #THREAD_LOCAL_ACCESS
+        def convert_N_trace_nodes_to_arrays(count_to_keep)
           all_nodes = @traces.values.map { |n| n.flattened }.flatten
 
-          OneApm::Agent.instance.stats_engine.
+          OneApm::Manager.agent.stats_engine.
             tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
 
           all_nodes.sort! do |a, b|

data/lib/one_apm/collector/collector/helper.rb

@@ -4,8 +4,8 @@ module OneApm
       module Helper
 
         def handle_serialization_error(method, e)
-          OneApm::Agent.increment_metric("Supportability/serialization_failure")
-          OneApm::Agent.increment_metric("Supportability/serialization_failure/#{method}")
+          OneApm::Manager.increment_metric("Supportability/serialization_failure")
+          OneApm::Manager.increment_metric("Supportability/serialization_failure/#{method}")
           msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
           error = SerializationError.new(msg)
           error.set_backtrace(e.backtrace)
@@ -15,11 +15,11 @@ module OneApm
         def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
           serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
           duration = (Time.now - start_ts).to_f
-          OneApm::Agent.record_metric("Supportability/invoke_remote", duration)
-          OneApm::Agent.record_metric("Supportability/invoke_remote/#{method.to_s}", duration)
+          OneApm::Manager.record_metric("Supportability/invoke_remote", duration)
+          OneApm::Manager.record_metric("Supportability/invoke_remote/#{method.to_s}", duration)
           if serialize_time
-            OneApm::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
-            OneApm::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
+            OneApm::Manager.record_metric("Supportability/invoke_remote_serialize", serialize_time)
+            OneApm::Manager.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
           end
         end
 
@@ -38,11 +38,11 @@ module OneApm
           ]
           # we may not have an item count, in which case, just record 0 for the exclusive time
           item_count ||= 0
-          OneApm::Agent.instance.stats_engine.tl_record_unscoped_metrics(metrics, size_bytes, item_count)
+          OneApm::Manager.agent.stats_engine.tl_record_unscoped_metrics(metrics, size_bytes, item_count)
         end
 
         def log_and_return_response(response)
-          ::OneApm::Agent.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
+          OneApm::Manager.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
 
           case response
           when Net::HTTPSuccess
@@ -82,7 +82,7 @@ module OneApm
           # If we've gotten this far, we don't want this error to propagate and
           # make this post appear to have been non-successful, which would trigger
           # re-aggregation of the same metric data into the next post, so just log
-          OneApm::Agent.logger.error("Failed to fill metric ID cache from response, error details follow ", e)
+          OneApm::Manager.logger.error("Failed to fill metric ID cache from response, error details follow ", e)
         end
 
         # The collector wants to recieve metric data in a format that's different
@@ -109,7 +109,7 @@ module OneApm
           @marshaller.dump(data)
           true
         rescue StandardError, SystemStackError => e
-          OneApm::Agent.logger.warn("Unable to marshal environment report on connect.", e)
+          OneApm::Manager.logger.warn("Unable to marshal environment report on connect.", e)
           false
         end
 

data/lib/one_apm/collector/collector/http_connection.rb

@@ -74,14 +74,14 @@ module OneApm
           begin
             attempts += 1
             conn = http_connection
-            ::OneApm::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
+            OneApm::Manager.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
             OneApm::TimerLib.timeout(@request_timeout) do
               response = conn.request(request)
             end
           rescue *CONNECTION_ERRORS => e
             close_shared_connection
             if attempts < max_attempts
-              ::OneApm::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+              OneApm::Manager.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
               retry
             else
               raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
@@ -97,7 +97,7 @@ module OneApm
           begin
             t0 = Time.now
             @in_session = true
-            if OneApm::Agent.config[:aggressive_keepalive]
+            if OneApm::Manager.config[:aggressive_keepalive]
               session_with_keepalive(&block)
             else
               session_without_keepalive(&block)
@@ -141,7 +141,7 @@ module OneApm
 
         def close_shared_connection
           if @shared_tcp_connection
-            ::OneApm::Agent.logger.debug("Closing shared TCP connection to #{@shared_tcp_connection.address}:#{@shared_tcp_connection.port}")
+            OneApm::Manager.logger.debug("Closing shared TCP connection to #{@shared_tcp_connection.address}:#{@shared_tcp_connection.port}")
             @shared_tcp_connection.finish if @shared_tcp_connection.started?
             @shared_tcp_connection = nil
           end
@@ -151,8 +151,8 @@ module OneApm
           # We use Timeout explicitly instead of this
           conn.read_timeout = nil
 
-          if conn.respond_to?(:keep_alive_timeout) && OneApm::Agent.config[:aggressive_keepalive]
-            conn.keep_alive_timeout = OneApm::Agent.config[:keep_alive_timeout]
+          if conn.respond_to?(:keep_alive_timeout) && OneApm::Manager.config[:aggressive_keepalive]
+            conn.keep_alive_timeout = OneApm::Manager.config[:keep_alive_timeout]
           end
         end
 
@@ -163,7 +163,7 @@ module OneApm
         end
 
         def start_connection(conn)
-          OneApm::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
+          OneApm::Manager.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
           OneApm::TimerLib.timeout(@request_timeout) { conn.start }
           conn
         end
@@ -175,10 +175,10 @@ module OneApm
                                         proxy_server.user, proxy_server.password)
 
           conn = http_class.new((@collector.ip || @collector.name), @collector.port)
-          setup_connection_for_ssl(conn) if Agent.config[:ssl]
+          setup_connection_for_ssl(conn) if OneApm::Manager.config[:ssl]
           setup_connection_timeouts(conn)
 
-          ::OneApm::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
+          OneApm::Manager.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
           conn
         end
 
@@ -198,7 +198,7 @@ module OneApm
         def ssl_cert_store
           path = cert_file_path
           if !@ssl_cert_store || path != @cached_cert_store_path
-            ::OneApm::Agent.logger.debug("Creating SSL certificate store from file at #{path}")
+            OneApm::Manager.logger.debug("Creating SSL certificate store from file at #{path}")
             @ssl_cert_store = OpenSSL::X509::Store.new
             @ssl_cert_store.add_file(path)
             @cached_cert_store_path = path
@@ -209,8 +209,8 @@ module OneApm
         # The path to the certificate file used to verify the SSL
         # connection if verify_peer is enabled
         def cert_file_path
-          if path_override = OneApm::Agent.config[:ca_bundle_path]
-            OneApm::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exists? path_override
+          if path_override = OneApm::Manager.config[:ca_bundle_path]
+            OneApm::Manager.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exists? path_override
             path_override
           else
             File.expand_path(File.join(probe.oneapm_root, 'config', 'cert', 'cacert.pem'))
@@ -243,8 +243,8 @@ module OneApm
         # Raises an UnrecoverableServerException if the post_string is longer
         # than the limit configured in the probe object
         def check_post_size(post_string)
-          return if post_string.size < Agent.config[:post_size_limit]
-          ::OneApm::Agent.logger.debug "Tried to send too much data: #{post_string.size} bytes"
+          return if post_string.size < OneApm::Manager.config[:post_size_limit]
+          OneApm::Manager.logger.debug "Tried to send too much data: #{post_string.size} bytes"
           raise UnrecoverableServerException.new('413 Request Entity Too Large')
         end
 

data/lib/one_apm/collector/collector/server_methods.rb

@@ -16,19 +16,19 @@ module OneApm
         # there is no proxy, otherwise it has proxy configuration
         # information pulled from the config file
         def proxy_server
-          @proxy_server ||= OneApm::Support::ProxyServer.new(Agent.config[:proxy_host],
-                                                             Agent.config[:proxy_port],
-                                                             Agent.config[:proxy_user],
-                                                             Agent.config[:proxy_pass])
+          @proxy_server ||= OneApm::Support::ProxyServer.new(Manager.config[:proxy_host],
+                                                             OneApm::Manager.config[:proxy_port],
+                                                             OneApm::Manager.config[:proxy_user],
+                                                             OneApm::Manager.config[:proxy_pass])
         end
 
         # turns a hostname into an ip address and returns a
         # OneApm::Support::Server that contains the configuration info
         def server_from_host(hostname=nil)
-          host = hostname || Agent.config[:host]
+          host = hostname || OneApm::Manager.config[:host]
 
           # if the host is not an IP address, turn it into one
-          OneApm::Support::Server.new(host, Agent.config[:port], convert_to_ip_address(host))
+          OneApm::Support::Server.new(host, OneApm::Manager.config[:port], convert_to_ip_address(host))
         end
 
         # Check to see if we need to look up the IP address
@@ -38,13 +38,13 @@ module OneApm
         def convert_to_ip_address(host)
           # here we leave it as a host name since the cert verification
           # needs it in host form
-          return host if Agent.config[:ssl]
+          return host if OneApm::Manager.config[:ssl]
           # We won't talk directly to the host, so no need to resolve if proxy configured
-          return host if Agent.config[:proxy_host]
+          return host if OneApm::Manager.config[:proxy_host]
           return nil if host.nil? || host.downcase == "localhost"
           ip = resolve_ip_address(host)
 
-          OneApm::Agent.logger.debug "Resolved #{host} to #{ip}"
+          OneApm::Manager.logger.debug "Resolved #{host} to #{ip}"
           ip
         end
 
@@ -55,12 +55,12 @@ module OneApm
         def resolve_ip_address(host)
           Resolv.getaddress(host)
         rescue => e
-          OneApm::Agent.logger.warn("DNS Error caching IP address:", e)
+          OneApm::Manager.logger.warn("DNS Error caching IP address:", e)
           begin
-            OneApm::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
+            OneApm::Manager.logger.debug("Trying native DNS lookup since Resolv failed")
             IPSocket.getaddress(host)
           rescue => e
-            OneApm::Agent.logger.error("Could not look up server address: #{e}")
+            OneApm::Manager.logger.error("Could not look up server address: #{e}")
             nil
           end
         end

data/lib/one_apm/collector/collector_service.rb

@@ -22,25 +22,25 @@ module OneApm
       attr_reader :collector,:marshaller, :metric_id_cache
 
       def initialize(license_key = nil, collector = nil)
-        @license_key = license_key || Agent.config[:license_key]
+        @license_key = license_key || OneApm::Manager.config[:license_key]
         @collector = collector || server
-        @request_timeout = Agent.config[:timeout]
+        @request_timeout = OneApm::Manager.config[:timeout]
         @metric_id_cache = {}
-        @audit_logger = ::OneApm::Agent::AuditLogger.new
+        @audit_logger = ::OneApm::Logger::AuditLogger.new
 
-        Agent.config.register_callback(:'audit_log.enabled') do |enabled|
+        OneApm::Manager.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
 
-        Agent.config.register_callback(:ssl) do |ssl|
+        OneApm::Manager.config.register_callback(:ssl) do |ssl|
           if !ssl
-            OneApm::Agent.logger.warn("Agent is configured not to use SSL when communicating with OneApm's servers")
+            OneApm::Manager.logger.warn("Agent is configured not to use SSL when communicating with OneApm's servers")
           else
-            OneApm::Agent.logger.debug("Agent is configured to use SSL")
+            OneApm::Manager.logger.debug("Agent is configured to use SSL")
           end
         end
 
-        Agent.config.register_callback(:marshaller) do |marshaller|
+        OneApm::Manager.config.register_callback(:marshaller) do |marshaller|
           @marshaller = OneApm::Support::JsonMarshaller.new
         end
       end

data/lib/one_apm/collector/commands/thread_profiler_session.rb

@@ -27,7 +27,7 @@ module OneApm
         end
 
         def start(agent_command)
-          OneApm::Agent.logger.debug("Starting Thread Profiler.")
+          OneApm::Manager.logger.debug("Starting Thread Profiler.")
           profile = @backtrace_service.subscribe(
             OneApm::Agent::Threading::BacktraceService::ALL_TRANSACTIONS,
             agent_command.arguments
@@ -39,14 +39,14 @@ module OneApm
 
         def stop(report_data)
           return unless running?
-          OneApm::Agent.logger.debug("Stopping Thread Profiler.")
+          OneApm::Manager.logger.debug("Stopping Thread Profiler.")
           @finished_profile = @backtrace_service.harvest(OneApm::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @backtrace_service.unsubscribe(OneApm::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @finished_profile = nil if !report_data
         end
 
         def harvest
-          OneApm::Agent.logger.debug("Harvesting from Thread Profiler #{@finished_profile.to_log_description unless @finished_profile.nil?}")
+          OneApm::Manager.logger.debug("Harvesting from Thread Profiler #{@finished_profile.to_log_description unless @finished_profile.nil?}")
           profile = @finished_profile
           @backtrace_service.profile_agent_code = false
           @finished_profile = nil
@@ -55,7 +55,7 @@ module OneApm
         end
 
         def enabled?
-          OneApm::Agent.config[:'thread_profiler.enabled']
+          OneApm::Manager.config[:'thread_profiler.enabled']
         end
 
         def running?

data/lib/one_apm/collector/commands/xray_session.rb

@@ -28,7 +28,7 @@ module OneApm
         end
 
         def run_profiler?
-          @run_profiler && OneApm::Agent.config[:'xray_session.allow_profiles']
+          @run_profiler && OneApm::Manager.config[:'xray_session.allow_profiles']
         end
 
         def activate

data/lib/one_apm/collector/commands/xray_session_collection.rb

@@ -29,8 +29,8 @@ module OneApm
           # If X-Rays are disabled, just be quiet about it and don't start the
           # command. Other hosts might be running the X-Ray, so we don't need
           # to bark on every get_agent_commands.
-          if !OneApm::Agent.config[:'xray_session.enabled']
-            OneApm::Agent.logger.debug("Not responding to X-Ray command because of config 'xray_session.enabled' = #{OneApm::Agent.config[:'xray_session.enabled']}")
+          if !OneApm::Manager.config[:'xray_session.enabled']
+            OneApm::Manager.logger.debug("Not responding to X-Ray command because of config 'xray_session.enabled' = #{OneApm::Manager.config[:'xray_session.enabled']}")
             return
           end
 
@@ -51,7 +51,7 @@ module OneApm
           return NO_PROFILES unless OneApm::Agent::Threading::BacktraceService.is_supported?
 
           profiles = active_thread_profiling_sessions.map do |session|
-            OneApm::Agent.logger.debug("Harvesting profile for X-Ray session #{session.inspect}")
+            OneApm::Manager.logger.debug("Harvesting profile for X-Ray session #{session.inspect}")
             @backtrace_service.harvest(session.key_transaction_name)
           end
           profiles.reject! {|p| p.empty?}
@@ -64,7 +64,7 @@ module OneApm
 
         def cleanup_finished_sessions
           finished_session_ids.each do |id|
-            OneApm::Agent.logger.debug("Finished X-Ray session #{id} by duration. Removing it from active sessions.")
+            OneApm::Manager.logger.debug("Finished X-Ray session #{id} by duration. Removing it from active sessions.")
             remove_session_by_id(id)
           end
         end
@@ -73,7 +73,7 @@ module OneApm
         ### Internals
 
         def one_apm_service
-          OneApm::Agent.instance.service
+          OneApm::Manager.agent.service
         end
 
         # These are unsynchonized and should only be used for testing
@@ -102,13 +102,13 @@ module OneApm
         def lookup_metadata_for(ids_to_activate)
           return [] if ids_to_activate.empty?
 
-          OneApm::Agent.logger.debug("Retrieving metadata for X-Ray sessions #{ids_to_activate.inspect}")
+          OneApm::Manager.logger.debug("Retrieving metadata for X-Ray sessions #{ids_to_activate.inspect}")
           one_apm_service.get_xray_metadata(ids_to_activate)
         end
 
         def add_session(session)
-          OneApm::Agent.logger.debug("Adding X-Ray session #{session.inspect}")
-          OneApm::Agent.increment_metric("Supportability/XraySessions/Starts")
+          OneApm::Manager.logger.debug("Adding X-Ray session #{session.inspect}")
+          OneApm::Manager.increment_metric("Supportability/XraySessions/Starts")
 
           @sessions_lock.synchronize { @sessions[session.id] = session }
 
@@ -134,8 +134,8 @@ module OneApm
           session = @sessions_lock.synchronize { @sessions.delete(id) }
 
           if session
-            OneApm::Agent.logger.debug("Removing X-Ray session #{session.inspect}")
-            OneApm::Agent.increment_metric("Supportability/XraySessions/Stops")
+            OneApm::Manager.logger.debug("Removing X-Ray session #{session.inspect}")
+            OneApm::Manager.increment_metric("Supportability/XraySessions/Stops")
 
             if session.run_profiler?
               @backtrace_service.unsubscribe(session.key_transaction_name)