oneapm_rpm 1.1.0

data/config/database.yml

@@ -0,0 +1,5 @@
+# This config is used when setting up a basic rails environment for running the
+# unit tests.
+test:
+  database: ':memory:'
+  adapter: 'sqlite3'

data/lib/initializers/goliath.rb

@@ -0,0 +1,11 @@
+module Goliath::Application
+  singleton_class.class_eval do
+    def run_with_oneapm
+      OneApm::Probe.init :env => Goliath.env.to_s
+      run_without_oneapm
+    end
+
+    alias_method :run_without_oneapm, :run!
+    alias_method :run!, :run_with_oneapm
+  end
+end

data/lib/initializers/other.rb

@@ -0,0 +1 @@
+OneApm::Probe.init

data/lib/initializers/rails.rb

@@ -0,0 +1,15 @@
+if Rails::VERSION::MAJOR.to_i >= 3
+  module OneApm
+    class Railtie < Rails::Railtie
+
+      initializer "oneapm_rpm.start_plugin" do |app|
+        OneApm::Probe.init :config => app.config
+      end
+
+    end
+  end
+else
+  config = nil
+  config = Rails.configuration if Rails.respond_to?(:configuration)
+  OneApm::Probe.init :config => config
+end

data/lib/one_apm/agent.rb

@@ -0,0 +1,253 @@
+# 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/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/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/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'
+
+module OneApm
+  module Agent
+    extend self
+
+    @agent = nil
+
+    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
+
+    def instance=(new_instance)
+      @agent = new_instance
+    end
+
+    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
+
+    alias_method :manual_start, :start
+
+    def shutdown(options={})
+      instance.shutdown(options) if instance
+    end
+
+    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
+
+    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 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
+
+    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
+
+    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 = instance.set_record_sql(false)
+      begin
+        yield
+      ensure
+        instance.set_record_sql(state)
+      end
+    end
+
+    def disable_transaction_tracing
+      state = instance.set_record_tt(false)
+      begin
+        yield
+      ensure
+        instance.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
+      instance.push_trace_execution_flag(false)
+      yield
+    ensure
+      instance.pop_trace_execution_flag
+    end
+
+    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)
+      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)
+      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 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}")
+      end
+    end
+
+    def set_transaction_name(name, options={})
+      Transaction.set_overriding_transaction_name(name, options[:category])
+    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))}"), '')
+      end
+    end
+
+    def with_database_metric_name(model, method, &block) #THREAD_LOCAL_ACCESS
+      if txn = Transaction.tl_current
+        txn.with_database_metric_name(model, method, &block)
+      else
+        yield
+      end
+    end
+
+    def subscribe(event_type, &handler)
+      instance.events.subscribe( event_type, &handler )
+    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
+
+    def browser_timing_header
+      instance.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/agent/agent.rb

@@ -0,0 +1,283 @@
+# encoding: utf-8
+
+require 'socket'
+require 'net/https'
+require 'net/http'
+require 'logger'
+require 'zlib'
+require 'stringio'
+
+require 'one_apm/support/event_buffer/sampled_buffer'
+require 'one_apm/configuration/autostart'
+require 'one_apm/agent/harvester'
+
+require 'one_apm/support/hostname'
+require 'one_apm/support/environment_report'
+
+require 'one_apm/configuration'
+
+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/pipe/pipe_service'
+require 'one_apm/agent/database'
+require 'one_apm/agent/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
+    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
+
+      # whether we should record raw, obfuscated, or no sql
+      attr_reader :record_sql
+      # builder for JS agent scripts to inject
+      attr_reader :javascript_instrumentor
+      # cross application tracing ids and encoding
+      attr_reader :cross_process_id
+      attr_reader :cross_app_encoding_bytes
+      attr_reader :cross_app_monitor
+      # service for communicating with collector
+      attr_accessor :service
+      # Global events dispatcher. This will provides our primary mechanism
+      # for agent-wide events, such as finishing configuration, error notification
+      # and request before/after from Rack.
+      attr_reader :events
+      # Transaction and metric renaming rules as provided by the
+      # collector on connect.  The former are applied during txns,
+      # the latter during harvest.
+      attr_reader :transaction_rules
+      # Responsbile for restarting the harvest thread
+      attr_reader :harvester
+      attr_reader :harvest_samplers
+      attr_reader :harvest_lock
+      # GC::Profiler.total_time is not monotonic so we wrap it.
+      attr_reader :monotonic_gc_profiler
+
+      def self.instance
+        @instance ||= self.new
+      end
+
+      def self.config
+        OneApm::Agent.config
+      end
+
+      def initialize
+        # This should be handled with a configuration callback
+        start_service_if_needed
+
+        @events = OneApm::Agent::EventListener.new
+
+        init_containers @events
+        OneApm::Agent::SyntheticsMonitor.new @events
+
+        @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)
+
+        @harvester       = OneApm::Agent::Harvester.new(@events)
+        @after_fork_lock = Mutex.new
+
+        @connect_state      = :pending
+        @connect_attempts   = 0
+        @environment_report = nil
+
+        @harvest_lock = Mutex.new
+      end
+
+      def probe
+        OneApm::Probe.instance
+      end
+
+      def start_service_if_needed
+        if Agent.config[:monitor_mode] && !@service
+          @service = OneApm::Collector::CollectorService.new
+        end
+      end
+
+      def start
+        return unless agent_should_start?
+
+        log_startup
+        check_config_and_start_agent
+        log_version_and_pid
+
+        events.subscribe(:finished_configuring) do
+          log_ignore_url_regexes
+        end
+      end
+
+      # Attempt a graceful shutdown of the agent, running the worker
+      # loop if it exists and is running.
+      #
+      # Options:
+      # :force_send  => (true/false) # force the agent to send data
+      def shutdown(options={})
+        return if not started?
+        ::OneApm::Agent.logger.info "Starting Agent shutdown"
+
+        stop_event_loop
+        untraced_graceful_disconnect
+        OneApm::Agent.revert_to_default_configuration
+
+        @started = nil
+        OneApm::Probe.reset
+      end
+
+      # Check to see if the agent should start, returning +true+ if it should.
+      def agent_should_start?
+        return false if already_started? || disabled? || defer_for_background_jobs?
+
+        unless app_name_configured?
+          OneApm::Agent.logger.error "No application name configured.",
+            "The Agent cannot start without at least one. Please check your ",
+            "oneapm.yml and ensure that it is valid and has at least one ",
+            "value set for app_name in the #{probe.env} ",
+            "environment."
+          return false
+        end
+
+        true
+      end
+
+      # Connect to the server and validate the license.  If successful,
+      # connected? returns true when finished.  If not successful, you can
+      # keep calling this.  Return false if we could not establish a
+      # connection with the server and we should not retry, such as if
+      # there's a bad license key.
+      #
+      # Set keep_retrying=false to disable retrying and return asap, such as when
+      # invoked in the foreground.  Otherwise this runs until a successful
+      # connection is made, or the server rejects us.
+      #
+      # * <tt>:keep_retrying => false</tt> to only try to connect once, and
+      #   return with the connection set to nil.  This ensures we may try again
+      #   later (default true).
+      # * <tt>force_reconnect => true</tt> if you want to establish a new connection
+      #   to the server before running the worker loop.  This means you get a separate
+      #   agent run and OneApm sees it as a separate instance (default is false).
+      def connect(options={})
+        begin
+          defaults = {
+            :keep_retrying => Agent.config[:keep_retrying],
+            :force_reconnect => Agent.config[:force_reconnect]
+          }
+          opts = defaults.merge(options)
+
+          return unless should_connect?(opts[:force_reconnect])
+
+          ::OneApm::Agent.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::Agent.logger.info "Will re-attempt in #{connect_retry_period} seconds"
+            sleep connect_retry_period
+            retry
+          else
+            disconnect
+          end
+        rescue Exception => e
+          ::OneApm::Agent.logger.error "Exception of unexpected type during Agent#connect():", e
+
+          raise
+        end
+      end
+
+      # This method contacts the server to send remaining data and
+      # let the server know that the agent is shutting down - this
+      # allows us to do things like accurately set the end of the
+      # lifetime of the process
+      #
+      # If this process comes from a parent process, it will not
+      # disconnect, so that the parent process can continue to send data
+      def graceful_disconnect
+        if connected?
+          begin
+            @service.request_timeout = 10
+
+            @events.notify(:before_shutdown)
+            transmit_data
+            transmit_event_data
+            transmit_utilization_data if OneApm::Agent.config[:collect_utilization]
+
+            if @connected_pid == $$ && !@service.kind_of?(OneApm::Collector::CollectorService)
+              ::OneApm::Agent.logger.debug "Sending OneApm service agent run shutdown message"
+              @service.shutdown(Time.now.to_f)
+            else
+              ::OneApm::Agent.logger.debug "This agent connected from parent process #{@connected_pid}--not sending shutdown"
+            end
+            ::OneApm::Agent.logger.debug "Graceful disconnect complete"
+          rescue Timeout::Error, StandardError => e
+            ::OneApm::Agent.logger.debug "Error when disconnecting #{e.class.name}: #{e.message}"
+          end
+        else
+          ::OneApm::Agent.logger.debug "Bypassing graceful disconnect - agent not connected"
+        end
+      end
+
+      def untraced_graceful_disconnect
+        begin
+          OneApm::Agent.disable_all_tracing do
+            graceful_disconnect
+          end
+        rescue => e
+          ::OneApm::Agent.logger.error e
+        end
+      end
+    end
+
+    class ShimAgent < OneApm::Agent::Agent
+      def self.instance
+        @instance ||= self.new
+      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 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