oneapm_rpm 1.1.0

data/lib/one_apm/agent/inbound_request_monitor.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    class InboundRequestMonitor
+
+      attr_reader :obfuscator
+
+      def initialize(events)
+        events.subscribe(:finished_configuring) do
+          setup_obfuscator
+          on_finished_configuring(events)
+        end
+      end
+
+      def setup_obfuscator
+        @obfuscator = OneApm::Agent::Obfuscator.new(OneApm::Agent.config[:encoding_key])
+      end
+
+      def deserialize_header(encoded_header, key)
+        decoded_header = obfuscator.deobfuscate(encoded_header)
+        OneApm::JSONWrapper.load(decoded_header)
+      rescue => err
+        OneApm::Agent.logger.debug("Failure deserializing encoded header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
+        nil
+      end
+
+    end
+  end
+end

data/lib/one_apm/agent/javascript_instrumentor.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+
+require 'base64'
+require 'one_apm/support/obfuscator'
+require 'one_apm/transaction/transaction_timings'
+
+module OneApm
+  module Agent
+    class JavascriptInstrumentor
+      include OneApm::Coerce
+
+      RUM_KEY_LENGTH = 13
+
+      def initialize(event_listener)
+        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+      end
+
+      def log_configuration
+        OneApm::Agent.logger.debug("JS agent loader requested: #{OneApm::Agent.config[:'browser_monitoring.loader']}",
+                                     "JS agent loader debug: #{OneApm::Agent.config[:'browser_monitoring.debug']}",
+                                     "JS agent loader version: #{OneApm::Agent.config[:'browser_monitoring.loader_version']}")
+
+        if !OneApm::Agent.config[:'rum.enabled']
+          OneApm::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
+        end
+      end
+
+      def enabled?
+        Agent.config[:'rum.enabled'] && !!Agent.config[:beacon]
+      end
+
+      def obfuscator
+        @obfuscator ||= OneApm::Agent::Obfuscator.new(OneApm::Agent.config[:license_key], RUM_KEY_LENGTH)
+      end
+
+      def js_enabled_and_ready?
+        if !enabled?
+          ::OneApm::Agent.logger.log_once(:debug, :js_agent_disabled,
+                                            "JS agent instrumentation is disabled.")
+          false
+        elsif missing_config?(:js_agent_loader)
+          ::OneApm::Agent.logger.log_once(:debug, :missing_js_agent_loader,
+                                            "Missing :js_agent_loader. Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:beacon)
+          ::OneApm::Agent.logger.log_once(:debug, :missing_beacon,
+                                            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:browser_key)
+          ::OneApm::Agent.logger.log_once(:debug, :missing_browser_key,
+                                            "Browser key is not set. Skipping browser instrumentation.")
+          false
+        else
+          true
+        end
+      rescue => e
+        ::OneApm::Agent.logger.debug "Failure during 'js_enabled_and_ready?'", e
+        false
+      end
+
+      def insert_js?(state)
+        if !state.current_transaction
+          ::OneApm::Agent.logger.debug "Not in transaction. Skipping browser instrumentation."
+          false
+        elsif !state.is_transaction_traced?
+          ::OneApm::Agent.logger.debug "Transaction is not traced. Skipping browser instrumentation."
+          false
+        elsif !state.is_execution_traced?
+          ::OneApm::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
+          false
+        elsif state.current_transaction.ignore_enduser?
+          ::OneApm::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
+          false
+        else
+          true
+        end
+      rescue => e
+        ::OneApm::Agent.logger.debug "Failure during insert_js", e
+        false
+      end
+
+      def missing_config?(key)
+        value = OneApm::Agent.config[key]
+        value.nil? || value.empty?
+      end
+
+      def browser_timing_header #THREAD_LOCAL_ACCESS
+        return '' unless js_enabled_and_ready? # fast exit
+
+        state = OneApm::TransactionState.tl_get
+
+        return '' unless insert_js?(state) # slower exit
+
+        bt_config = browser_timing_config(state)
+        return '' if bt_config.empty?
+
+        bt_config + browser_timing_loader
+      rescue => e
+        ::OneApm::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
+        ''
+      end
+
+      def browser_timing_loader
+        html_safe_if_needed("\n<script type=\"text/javascript\" src=\"#{Agent.config[:js_agent_loader]}\"></script>")
+      end
+
+      def browser_timing_config(state)
+        txn = state.current_transaction
+        return '' if txn.nil?
+
+        txn.freeze_name_and_execute_if_not_ignored do
+          data = data_for_js_agent(state)
+          json = OneApm::JSONWrapper.dump(data)
+          return html_safe_if_needed("\n<script type=\"text/javascript\">window.BWEUM||(BWEUM={});BWEUM.info=#{json}</script>")
+        end
+
+        ''
+      end
+
+      BEACON_KEY           = "beacon".freeze
+      ERROR_BEACON_KEY     = "errorBeacon".freeze
+      LICENSE_KEY_KEY      = "licenseKey".freeze
+      APPLICATIONID_KEY    = "applicationID".freeze
+      TRANSACTION_NAME_KEY = "transactionName".freeze
+      QUEUE_TIME_KEY       = "queueTime".freeze
+      APPLICATION_TIME_KEY = "applicationTime".freeze
+      AGENT_KEY            = "agent".freeze
+      USER_ATTRIBUTES_KEY  = "userAttributes".freeze
+      SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
+
+      # NOTE: Internal prototyping may override this, so leave name stable!
+      def data_for_js_agent(state)
+        timings = state.timings
+
+        data = {
+          BEACON_KEY           => OneApm::Agent.config[:beacon],
+          ERROR_BEACON_KEY     => OneApm::Agent.config[:error_beacon],
+          LICENSE_KEY_KEY      => OneApm::Agent.config[:browser_key],
+          APPLICATIONID_KEY    => OneApm::Agent.config[:application_id],
+          TRANSACTION_NAME_KEY => obfuscator.obfuscate(timings.transaction_name_or_unknown),
+          QUEUE_TIME_KEY       => timings.queue_time_in_millis,
+          APPLICATION_TIME_KEY => timings.app_time_in_millis,
+          AGENT_KEY            => OneApm::Agent.config[:js_agent_file]
+        }
+
+        add_ssl_for_http(data)
+        add_user_attributes(data, state.current_transaction)
+
+        data
+      end
+
+      def add_ssl_for_http(data)
+        ssl_for_http = OneApm::Agent.config[:'browser_monitoring.ssl_for_http']
+        unless ssl_for_http.nil?
+          data[SSL_FOR_HTTP_KEY] = ssl_for_http
+        end
+      end
+
+      def add_user_attributes(data, txn)
+        return unless include_custom_parameters?(txn)
+
+        params = event_params(txn.custom_parameters)
+        json = OneApm::JSONWrapper.dump(params)
+        data[USER_ATTRIBUTES_KEY] = obfuscator.obfuscate(json)
+      end
+
+      # Still support deprecated capture_attributes.page_view_events for
+      # clients that use it. Could potentially be removed if we don't have
+      # anymore users with it set according to zeitgeist.
+      def include_custom_parameters?(txn)
+        has_custom_parameters?(txn) &&
+          (OneApm::Agent.config[:'browser_monitoring.capture_attributes'] ||
+           OneApm::Agent.config[:'capture_attributes.page_view_events'])
+      end
+
+      def has_custom_parameters?(txn)
+        txn && txn.custom_parameters && !txn.custom_parameters.empty?
+      end
+
+      def html_safe_if_needed(string)
+        string = string.html_safe if string.respond_to?(:html_safe)
+        string
+      end
+    end
+  end
+end

data/lib/one_apm/agent/pipe/pipe_channel_manager.rb

@@ -0,0 +1,275 @@
+# encoding: utf-8
+
+require 'base64'
+
+module OneApm
+  module Agent
+
+    #--
+    # Manages the registering and servicing of pipes used by child
+    # processes to report data to their parent, rather than directly
+    # to the collector.
+    module PipeChannelManager
+      extend self
+
+      def register_report_channel(id)
+        listener.register_pipe(id)
+      end
+
+      def channels
+        listener.pipes
+      end
+
+      def listener
+        @listener ||= Listener.new
+      end
+
+      # Expected initial sequence of events for Pipe usage:
+      #
+      # 1. Pipe is created in parent process (read and write ends open)
+      # 2. Parent process forks
+      # 3. An after_fork hook is invoked in the child
+      # 4. From after_fork hook, child closes read end of pipe, and
+      #    writes a ready marker on the pipe (after_fork_in_child).
+      # 5. The parent receives the ready marker, and closes the write end of the
+      #    pipe in response (after_fork_in_parent).
+      #
+      # After this sequence of steps, an exit (whether clean or not) of the
+      # child will result in the pipe being marked readable again, and giving an
+      # EOF marker (nil) when read. Note that closing of the unused ends of the
+      # pipe in the parent and child processes is essential in order for the EOF
+      # to be correctly triggered. The ready marker mechanism is used because
+      # there's no easy hook for after_fork in the parent process.
+      #
+      # This class provides message framing (separation of individual messages),
+      # but not serialization. Serialization / deserialization is the
+      # responsibility of clients.
+      #
+      # Message framing works like this:
+      #
+      # Each message sent across the pipe is preceded by a length tag that
+      # specifies the length of the message that immediately follows, in bytes.
+      # The length tags are serialized as unsigned big-endian long values, (4
+      # bytes each). This means that the maximum theoretical message size is
+      # 4 GB - much larger than we'd ever need or want for this application.
+      #
+      class Pipe
+        READY_MARKER = "READY"
+        NUM_LENGTH_BYTES = 4
+
+        attr_accessor :in, :out
+        attr_reader :last_read, :parent_pid
+
+        def initialize
+          @out, @in = IO.pipe
+          if defined?(::Encoding::ASCII_8BIT)
+            @in.set_encoding(::Encoding::ASCII_8BIT)
+          end
+          @last_read = Time.now
+          @parent_pid = $$
+        end
+
+        def close
+          @out.close unless @out.closed?
+          @in.close unless @in.closed?
+        end
+
+        def serialize_message_length(data)
+          [data.bytesize].pack("L>")
+        end
+
+        def deserialize_message_length(data)
+          data.unpack("L>").first
+        end
+
+        def write(data)
+          @out.close unless @out.closed?
+          @in << serialize_message_length(data)
+          @in << data
+        end
+
+        def read
+          @in.close unless @in.closed?
+          @last_read = Time.now
+          length_bytes = @out.read(NUM_LENGTH_BYTES)
+          if length_bytes
+            message_length = deserialize_message_length(length_bytes)
+            if message_length
+              @out.read(message_length)
+            else
+              length_hex = length_bytes.bytes.map { |b| b.to_s(16) }.join(' ')
+              OneApm::Agent.logger.error("Failed to deserialize message length from pipe. Bytes: [#{length_hex}]")
+              nil
+            end
+          else
+            OneApm::Agent.logger.error("Failed to read bytes for length from pipe.")
+            nil
+          end
+        end
+
+        def eof?
+          !@out.closed? && @out.eof?
+        end
+
+        def after_fork_in_child
+          @out.close unless @out.closed?
+          write(READY_MARKER)
+        end
+
+        def after_fork_in_parent
+          @in.close unless @in.closed?
+        end
+
+        def closed?
+          @out.closed? && @in.closed?
+        end
+      end
+
+      class Listener
+        attr_reader   :thread
+
+        # This attr_accessor intentionally provides unsynchronized access to the
+        # @pipes hash. It is used to look up the write end of the pipe from
+        # within the Resque child process, and must be unsynchronized in order
+        # to avoid a potential deadlock in which the PipeChannelManager::Listener
+        # thread in the parent process is holding the @pipes_lock at the time of
+        # the fork.
+        attr_accessor :pipes, :timeout, :select_timeout
+
+        def initialize
+          @pipes = {}
+          @pipes_lock = Mutex.new
+
+          @timeout = 360
+          @select_timeout = 60
+        end
+
+        def wakeup
+          wake.in << '.'
+        end
+
+        def register_pipe(id)
+          @pipes_lock.synchronize do
+            @pipes[id] = Pipe.new
+          end
+
+          wakeup
+        end
+
+        def start
+          return if @started == true
+          @started = true
+          @thread = OneApm::Agent::Threading::AgentThread.create('Pipe Channel Manager') do
+            now = nil
+            loop do
+              clean_up_pipes
+
+              pipes_to_listen_to = @pipes_lock.synchronize do
+                @pipes.values.map{|pipe| pipe.out} + [wake.out]
+              end
+
+              OneApm::Agent.record_metric('Supportability/Listeners',
+                (Time.now - now).to_f) if now
+
+              if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
+                now = Time.now
+
+                ready_pipes = ready[0]
+                ready_pipes.each do |pipe|
+                  merge_data_from_pipe(pipe) unless pipe == wake.out
+                end
+
+                wake.out.read(1) if ready_pipes.include?(wake.out)
+              end
+
+              break unless should_keep_listening?
+            end
+          end
+          sleep 0.001 # give time for the thread to spawn
+        end
+
+        def stop_listener_thread
+          @started = false
+          wakeup
+          @thread.join
+        end
+
+        def stop
+          return unless @started == true
+          stop_listener_thread
+          close_all_pipes
+          @wake.close
+          @wake = nil
+        end
+
+        def close_all_pipes
+          @pipes_lock.synchronize do
+            @pipes.each do |id, pipe|
+              pipe.close if pipe
+            end
+            @pipes = {}
+          end
+        end
+
+        def wake
+          @wake ||= Pipe.new
+        end
+
+        def started?
+          @started
+        end
+
+        protected
+
+        def merge_data_from_pipe(pipe_handle)
+          pipe = find_pipe_for_handle(pipe_handle)
+          raw_payload = pipe.read
+          if raw_payload && !raw_payload.empty?
+            if raw_payload == Pipe::READY_MARKER
+              pipe.after_fork_in_parent
+            else
+              payload = unmarshal(raw_payload)
+              if payload
+                endpoint, items = payload
+                OneApm::Agent.instance.merge_data_for_endpoint(endpoint, items)
+              end
+            end
+          end
+
+          pipe.close if pipe.eof?
+        end
+
+        def unmarshal(data)
+          OneApm::LanguageSupport.with_cautious_gc do
+            Marshal.load(data)
+          end
+        rescue StandardError => e
+          ::OneApm::Agent.logger.error "Failure unmarshalling message from Resque child process", e
+          ::OneApm::Agent.logger.debug Base64.encode64(data)
+          nil
+        end
+
+        def should_keep_listening?
+          @started || @pipes_lock.synchronize { @pipes.values.find{|pipe| !pipe.in.closed?} }
+        end
+
+        def clean_up_pipes
+          @pipes_lock.synchronize do
+            @pipes.values.each do |pipe|
+              if pipe.last_read.to_f + @timeout < Time.now.to_f
+                pipe.close unless pipe.closed?
+              end
+            end
+            @pipes.reject! {|id, pipe| pipe.out.closed? }
+          end
+        end
+
+        def find_pipe_for_handle(out_handle)
+          @pipes_lock.synchronize do
+            @pipes.values.find{|pipe| pipe.out == out_handle }
+          end
+        end
+      end
+    end
+  end
+end