oneapm_rpm 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4759f9e2a49b073a72ef050065da0b3169782a50
-  data.tar.gz: e06c21dc7767a5c5ee0b2371eb367cb3286b1231
+  metadata.gz: 2549e99a228ebc5192a1fa035a985afc7bac2ace
+  data.tar.gz: d52a272c4e52693f21c973c51f8fa3cdd72081c3
 SHA512:
-  metadata.gz: 523b7b03147cb529a70bf76da7bdd1761621460169d4eeb74d972db31134eae5ab7d0430d693cd7e51d4699d66b71615de5b9a42b81ca45c8d7d4a23a3d2ddc1
-  data.tar.gz: 60387048069ae8167d4f237070131090558fb44104b47af2e5e86597f44eb2dcbef8223da1516fc37c13684e2da1e8a827a86a26765c2ee4ed8c0b9656c39d44
+  metadata.gz: 786db6b474c198e117000456a33c46538d7a0cf343082556361b04a2b1db2f442f65e2e5f4cbaa7d88772741ee10989f9193bb90ad5c7e2a4493a01a571c380e
+  data.tar.gz: 1d3c27a588fa01c9606cb79ac4120b862b1e453be7e1422eda17fef366fe84362c4f8e92a05312be7e40a9d0cd90bfb05c717303d708c688f89c313ff6653126

data/lib/one_apm/agent.rb

@@ -1,245 +1,238 @@
 # encoding: utf-8
 
-require 'one_apm/probe'
+require 'socket'
+require 'net/https'
+require 'net/http'
+require 'logger'
+require 'zlib'
+require 'stringio'
 
-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/support/event_buffer/sampled_buffer'
+require 'one_apm/configuration/autostart'
+require 'one_apm/agent/harvester'
 
-require 'one_apm/metrics/metric_spec'
-require 'one_apm/metrics/metric_data'
-require 'one_apm/metrics/stats'
+require 'one_apm/support/hostname'
+require 'one_apm/support/environment_report'
 
-require 'one_apm/errors/noticed_error'
-require 'one_apm/errors/agent_errors'
-
-require 'one_apm/agent/agent'
-require 'one_apm/agent/cross_app/cross_app_monitor'
-require 'one_apm/support/method_tracer'
-require 'one_apm/agent/event/worker_loop'
-require 'one_apm/agent/event/event_loop'
-require 'one_apm/transaction/transaction_sample'
+require 'one_apm/configuration'
 
-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/collector/collector_service'
+require 'one_apm/collector/containers/agent_command_router'
+require 'one_apm/collector/containers/transaction_event_aggregator'
+require 'one_apm/collector/containers/custom_event_aggregator'
+require 'one_apm/collector/containers/utilization_data'
 
-require 'one_apm/agent/busy_calculator'
+require 'one_apm/collector/forked_process_service'
 require 'one_apm/agent/database'
-require 'one_apm/agent/pipe/pipe_channel_manager'
-
-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'
+require 'one_apm/support/event/event_listener'
+require 'one_apm/agent/cross_app/cross_app_monitor'
+require 'one_apm/agent/synthetics_monitor'
+require 'one_apm/support/event_buffer/synthetics_event_buffer'
+require 'one_apm/agent/sampler_collection'
+require 'one_apm/agent/javascript_instrumentor'
+require 'one_apm/support/vm/monotonic_gc_profiler'
+
+require 'one_apm/agent/agent/start'
+require 'one_apm/agent/agent/start_worker_thread'
+require 'one_apm/agent/agent/connect'
+require 'one_apm/agent/agent/helpers'
+require 'one_apm/agent/agent/container_data_manager'
+require 'one_apm/agent/agent/forkable_dispatcher_functions'
 
 module OneApm
   module Agent
-    extend self
+    class Agent
+      include OneApm::Agent::Agent::Start
+      include OneApm::Agent::Agent::StartWorkerThread
+      include OneApm::Agent::Agent::Connect
+      include OneApm::Agent::Agent::Helpers
+      include OneApm::Agent::Agent::ContainerDataManager
+      include OneApm::Agent::Agent::ForkableDispatcherFunctions
 
-    @agent = nil
+      attr_reader :record_sql
+      attr_reader :javascript_instrumentor
 
-    def instance
-      return @agent if @agent
-      OneApm::Agent.logger.warn("Agent unavailable as it hasn't been started.")
-      OneApm::Agent.logger.warn(caller.join("\n"))
-      nil
-    end
+      attr_reader :cross_process_id
+      attr_reader :cross_app_encoding_bytes
+      attr_reader :cross_app_monitor
 
-    def instance=(new_instance)
-      @agent = new_instance
-    end
+      attr_accessor :service
 
-    def start(options = {})
-      raise "Options must be a hash" unless Hash === options
-      OneApm::Agent::PipeChannelManager.listener.start if options[:start_channel_listener]
-      OneApm::Probe.init({:agent_enabled => true, :sync_startup => true}.merge(options))
-    end
+      attr_reader :events
 
-    alias_method :manual_start, :start
+      attr_reader :transaction_rules
 
-    def shutdown(options={})
-      instance.shutdown(options) if instance
-    end
+      attr_reader :harvester
+      attr_reader :harvest_samplers
+      attr_reader :harvest_lock
 
-    def restart
-      OneApm::Agent.shutdown
-      OneApm::Agent.instance.harvest_samplers.clear
-      OneApm::Agent.instance.instance_variable_set(:@connect_state, :pending)
-      OneApm::Agent.instance.instance_variable_set(:@worker_thread, nil)
-      OneApm::Agent.instance.harvester.instance_variable_set(:@starting_pid, nil)
-      OneApm::Probe.init({:agent_enabled => true, :sync_startup => true})
-    end
-
-    def logger
-      @logger || StartupLogger.instance
-    end
+      attr_reader :monotonic_gc_profiler
 
-    def logger=(log)
-      @logger = log
-    end
+      def self.instance
+        @instance ||= self.new
+      end
 
-    def config
-      @config ||= OneApm::Configuration::Manager.new
-    end
+      def self.config
+        OneApm::Manager.config
+      end
 
-    def reset_config
-      @config.reset_to_defaults
-    end
+      def initialize
+        start_service
 
-    def revert_to_default_configuration
-      @config.remove_config_type(:manual)
-      @config.remove_config_type(:server)
-    end
+        @events = OneApm::Support::EventListener.new
 
-    def record_metric(metric_name, value) #THREAD_LOCAL_ACCESS
-      value_to_store = value
-      value_to_store = OneApm::Metrics::Stats.create_from_hash(value) if value.is_a?(Hash)
-      instance.stats_engine.tl_record_unscoped_metrics(metric_name, value_to_store)
-    end
+        init_containers @events
+        OneApm::Agent::SyntheticsMonitor.new @events
 
-    def increment_metric(metric_name, amount = 1) #THREAD_LOCAL_ACCESS
-      instance.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
-        stats.increment_count(amount)
-      end
-    end
-
-    def drop_buffered_data
-      instance.drop_buffered_data
-    end
+        @cross_app_monitor       = OneApm::Agent::CrossAppMonitor.new(@events)
+        @transaction_rules       = OneApm::Support::RulesEngine.new
+        @harvest_samplers        = OneApm::Agent::SamplerCollection.new(@events)
+        @monotonic_gc_profiler   = OneApm::Support::VM::MonotonicGCProfiler.new
+        @javascript_instrumentor = OneApm::Agent::JavascriptInstrumentor.new(@events)
 
-    def add_instrumentation(file_pattern)
-      OneApm::Probe.instance.add_instrumentation file_pattern
-    end
+        @harvester       = OneApm::Agent::Harvester.new(@events)
+        @after_fork_lock = Mutex.new
 
-    def set_sql_obfuscator(type = :replace, &block)
-      OneApm::Agent::Database.set_sql_obfuscator(type, &block)
-    end
+        @connect_state      = :pending
+        @connect_attempts   = 0
+        @environment_report = nil
 
-    def disable_sql_recording
-      state = instance.set_record_sql(false)
-      begin
-        yield
-      ensure
-        instance.set_record_sql(state)
+        @harvest_lock = Mutex.new
       end
-    end
 
-    def disable_transaction_tracing
-      state = instance.set_record_tt(false)
-      begin
-        yield
-      ensure
-        instance.set_record_tt(state)
+      def probe
+        OneApm::Probe.instance
       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 start_service
+        if OneApm::Manager.config[:monitor_mode] && !@service
+          @service = OneApm::Collector::CollectorService.new
+        end
+      end
 
-    def ignore_enduser
-      txn = OneApm::Transaction.tl_current
-      txn.ignore_enduser! if txn
-    end
+      def start
+        return unless agent_should_start?
 
-    def disable_all_tracing
-      instance.push_trace_execution_flag(false)
-      yield
-    ensure
-      instance.pop_trace_execution_flag
-    end
+        log_startup
+        check_config_and_start_agent
+        log_version_and_pid
 
-    def record_custom_event(event_type, event_attrs)
-      if instance && OneApm::Agent.config[:'custom_insights_events.enabled']
-        instance.custom_event_aggregator.record(event_type, event_attrs)
+        events.subscribe(:finished_configuring) do
+          log_ignore_url_regexes
+        end
       end
-      nil
-    end
 
-    def tl_is_execution_traced?
-      OneApm::TransactionState.tl_get.is_execution_traced?
-    end
+      def shutdown(options = {})
+        return if not started?
+        OneApm::Manager.logger.info "Starting Agent shutdown"
 
-    def tl_is_transaction_traced?
-      OneApm::TransactionState.tl_get.is_transaction_traced?
-    end
+        stop_event_loop
+        untraced_graceful_disconnect
+        OneApm::Manager.revert_to_default_configuration
 
-    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
+        @started = nil
+        OneApm::Probe.reset
       end
-    end
 
-    def notice_error(exception, options = {})
-      Transaction.notice_error(exception, options)
-      nil
-    end
-
-    def notice_sql(sql, metric, config, elapsed_time, state, &explainer)
-      instance.transaction_sampler.notice_sql(sql, config, elapsed_time, state, &explainer)
-      instance.sql_sampler.notice_sql(sql, metric, config, elapsed_time, state, &explainer)
-    end
+      def agent_should_start?
+        return false if already_started? || disabled? || defer_for_background_jobs?
 
-    def add_custom_parameters(params) #THREAD_LOCAL_ACCESS
-      if params.is_a? Hash
-        txn = Transaction.tl_current
-        txn.add_custom_parameters(params) if txn
-      else
-        ::OneApm::Agent.logger.warn("Bad argument passed to #add_custom_parameters. Expected Hash but got #{params.class}")
+        unless app_name_configured?
+          OneApm::Manager.logger.error "No application name configured in #{probe.env} environment"
+          false
+        else
+          true
+        end
       end
-    end
 
-    def set_transaction_name(name, options={})
-      Transaction.set_overriding_transaction_name(name, options[:category])
-    end
+      def connect(options={})
+        opts = {
+          :keep_retrying => OneApm::Manager.config[:keep_retrying],
+          :force_reconnect => OneApm::Manager.config[:force_reconnect]
+        }.merge(options)
+
+        return unless should_connect?(opts[:force_reconnect])
+
+        OneApm::Manager.logger.debug "Connecting Process to OneApm: #$0"
+        query_server_for_configuration
+        @connected_pid = Process.pid
+        @connect_state = :connected
+      rescue OneApm::ForceDisconnectException => e
+        handle_force_disconnect(e)
+      rescue OneApm::LicenseException => e
+        handle_license_error(e)
+      rescue OneApm::UnrecoverableAgentException => e
+        handle_unrecoverable_agent_error(e)
+      rescue StandardError, Timeout::Error, OneApm::ServerConnectionException => e
+        log_error(e)
+        if opts[:keep_retrying]
+          note_connect_failure
+          OneApm::Manager.logger.info "Will re-attempt in #{connect_retry_period} seconds"
+          sleep connect_retry_period
+          retry
+        else
+          disconnect
+        end
+      rescue Exception => e
+        OneApm::Manager.logger.error "Exception of unexpected type during Agent#connect():", e
+
+        raise
+      end
 
-    def get_transaction_name #THREAD_LOCAL_ACCESS
-      txn = Transaction.tl_current
-      if txn
-        txn.best_name.sub(Regexp.new("\\A#{Regexp.escape(OneApm::TransactionNamer.prefix_for_category(txn))}"), '')
+      def graceful_disconnect
+        if connected?
+          begin
+            @service.request_timeout = 10
+
+            @events.notify(:before_shutdown)
+            transmit_data
+            transmit_event_data
+            transmit_utilization_data if OneApm::Manager.config[:collect_utilization]
+
+            if @connected_pid == $$ && !@service.kind_of?(OneApm::Collector::CollectorService)
+              OneApm::Manager.logger.debug "Sending OneApm service agent run shutdown message"
+              @service.shutdown(Time.now.to_f)
+            else
+              OneApm::Manager.logger.debug "This agent connected from parent process #{@connected_pid}--not sending shutdown"
+            end
+            OneApm::Manager.logger.debug "Graceful disconnect complete"
+          rescue Timeout::Error, StandardError => e
+            OneApm::Manager.logger.debug "Error when disconnecting #{e.class.name}: #{e.message}"
+          end
+        else
+          OneApm::Manager.logger.debug "Bypassing graceful disconnect - agent not connected"
+        end
       end
-    end
 
-    def subscribe(event_type, &handler)
-      instance.events.subscribe( event_type, &handler )
+      def untraced_graceful_disconnect
+        OneApm::Manager.disable_all_tracing do
+          graceful_disconnect
+        end
+      rescue => e
+        OneApm::Manager.logger.error e
+      end
     end
 
-    def notify(event_type, *args)
-      instance.events.notify( event_type, *args )
-    rescue
-      OneApm::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
-    end
+    class ShimAgent < OneApm::Agent::Agent
+      def self.instance
+        @instance ||= self.new
+      end
 
-    def browser_timing_header
-      instance.javascript_instrumentor.browser_timing_header
-    end
+      def initialize
+        super
+        @stats_engine.extend OneApm::Collector::StatsEngine::Shim
+        @transaction_sampler.extend OneApm::Collector::TransactionSampler::Shim
+        @sql_sampler.extend OneApm::Collector::SqlSampler::Shim
+        @error_collector.extend OneApm::Collector::ErrorCollector::Shim
+      end
 
-    def require_test_helper
-      path = File.join(__FILE__, '..', '..', '..', 'test', 'agent_helper')
-      require File.expand_path(path)
+      def after_fork *args; end
+      def start *args; end
+      def shutdown *args; end
+      def merge_data_for_endpoint *args; end
+      def push_trace_execution_flag *args; end
+      def pop_trace_execution_flag *args; end
+      def browser_timing_header; "" end
     end
-
   end
 end

data/lib/one_apm/agent/agent/connect.rb

@@ -46,7 +46,7 @@ module OneApm
         # to tell the user what happened, since this is not an error
         # we can handle gracefully.
         def log_error(error)
-          ::OneApm::Agent.logger.error "Error establishing connection with OneApm Service at #{@service.server}:", error
+          OneApm::Manager.logger.error "Error establishing connection with OneApm Service at #{@service.server}:", error
         end
 
         # When the server sends us an error with the license key, we
@@ -57,14 +57,14 @@ module OneApm
         # no longer try to connect to the server, saving the
         # application and the server load
         def handle_license_error(error)
-          ::OneApm::Agent.logger.error( \
+          OneApm::Manager.logger.error( \
             error.message, \
             "Visit oneapm.com to obtain a valid license key, or to upgrade your account.")
           disconnect
         end
 
         def handle_unrecoverable_agent_error(error)
-          ::OneApm::Agent.logger.error(error.message)
+          OneApm::Manager.logger.error(error.message)
           disconnect
           shutdown
         end
@@ -79,7 +79,7 @@ module OneApm
         # require calls in Rails environments, so this method should only
         # be called synchronously from on the main thread.
         def environment_for_connect
-          Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
+          OneApm::Manager.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
         end
 
         # We've seen objects in the environment report (Rails.env in
@@ -98,20 +98,20 @@ module OneApm
           {
             :pid => $$,
             :host => local_host,
-            :app_name => Agent.config.app_names,
+            :app_name => OneApm::Manager.config.app_names,
             :language => 'ruby',
-            :labels => Agent.config.parsed_labels,
+            :labels => OneApm::Manager.config.parsed_labels,
             :agent_version => OneApm::VERSION::STRING,
             :environment => @environment_report,
-            :settings => Agent.config.to_collector_hash,
-            :high_security => Agent.config[:high_security],
+            :settings => OneApm::Manager.config.to_collector_hash,
+            :high_security => OneApm::Manager.config[:high_security],
             :identifier => "ruby:#{local_host}"
           }
         end
 
         # apdex_f is always 4 times the apdex_t
         def apdex_f
-          (4 * Agent.config[:apdex_t]).to_f
+          (4 * OneApm::Manager.config[:apdex_t]).to_f
         end
 
         # Sets the collector host and connects to the server, then
@@ -137,16 +137,16 @@ module OneApm
 
           @service.agent_id = config_data['agent_run_id'] if @service
 
-          ::OneApm::Agent.logger.debug "Server provided config: #{config_data.inspect}"
-          server_config = OneApm::Configuration::ServerSource.new(config_data, Agent.config)
-          Agent.config.replace_or_add_config(server_config)
+          OneApm::Manager.logger.debug "Server provided config: #{config_data.inspect}"
+          server_config = OneApm::Configuration::ServerSource.new(config_data, OneApm::Manager.config)
+          OneApm::Manager.config.replace_or_add_config(server_config)
           log_connection!(config_data) if @service
 
           @transaction_rules = OneApm::Support::RulesEngine.create_transaction_rules(config_data)
           @stats_engine.metric_rules = OneApm::Support::RulesEngine.create_metric_rules(config_data)
 
           # If you're adding something else here to respond to the server-side config,
-          # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
+          # use OneApm::Manager.agent.events.subscribe(:finished_configuring) callback instead!
         end
 
         def local_host
@@ -156,9 +156,9 @@ module OneApm
         # Logs when we connect to the server, for debugging purposes
         # - makes sure we know if an agent has not connected
         def log_connection!(config_data)
-          ::OneApm::Agent.logger.debug "Connected to OneApm Service at #{@service.collector.name}"
-          ::OneApm::Agent.logger.debug "Agent Run       = #{@service.agent_id}."
-          ::OneApm::Agent.logger.debug "Connection data = #{config_data.inspect}"
+          OneApm::Manager.logger.debug "Connected to OneApm Service at #{@service.collector.name}"
+          OneApm::Manager.logger.debug "Agent Run       = #{@service.agent_id}."
+          OneApm::Manager.logger.debug "Connection data = #{config_data.inspect}"
           if config_data['messages'] && config_data['messages'].any?
             log_collector_messages(config_data['messages'])
           end
@@ -166,7 +166,7 @@ module OneApm
 
         def log_collector_messages(messages)
           messages.each do |message|
-            ::OneApm::Agent.logger.send(message['level'].downcase, message['message'])
+            OneApm::Manager.logger.send(message['level'].downcase, message['message'])
           end
         end
       end