newrelic_rpm 5.4.0.347 → 5.5.0.348

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 979f362569155df00b770dba3907bd0eb894169f70b712085ae19d16852f53a7
-  data.tar.gz: b67e7d1c0cb1b5831f06d29c574f8efea5a95405a809b97c55add2e40d0cb101
+  metadata.gz: b17c73d708623383395fecf3a60a063566a12b59a10d2b18d686deef72f31773
+  data.tar.gz: f9b9275cf1f9f980175454d8ed5f06a4fa2d173c4edf52e136580c96b2e05eda
 SHA512:
-  metadata.gz: 2974f98ab0c47eb9f1c0e2014fb4122138fe4d1bf4d5265f8d09d1583f7ee8fc3f9ab5cb86bf1dc7e31d8b44d5762e56c8e1edd421120151ae85e3e2e4bd854d
-  data.tar.gz: 7d16296c46075e1e84824afaeff67db60ea39e0b5b4032bbae9bbcbde8c6c5ca6dc6d40618c92cbf29391f0ba36876937e8d2444313d3805031827a7e8313607
+  metadata.gz: 8cc16f8281e2e00829add33da0ba8053afbfe29e56b9e901c40d40cd44be982df5859492a26041aed7593b687316848113dcc02b646816e2812132bda4a86db5
+  data.tar.gz: 7eecd067c7606152a08e6485c6f0a642f5e73081812b011f89ba8d2b3fdd74df66ee0686e385d078ec4a4286e396a1ee9206bbc9c2585925596b9b7e90101015

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # New Relic Ruby Agent Release Notes #
 
+## v5.5.0
+
+  * Bugfix for `perform` instrumentation with curb gem
+
+    Use of curb's `perform` method now no longer results in nil headers
+    getting returned.
+
+  * Bugfix for parsing Docker container IDs
+
+    The agent now parses Docker container IDs correctly regardless of the
+    cgroup parent.
+
+  * Use lazy load hooks for ActiveJob instrumentation
+
+    In some instances the ActiveJob instrumentation could trigger ActiveJob
+    to load before it was initialized by Rails. This could result in
+    configuration changes not being properly applied. The agent now uses lazy
+    load hooks which fixes this issue.
+
+  * Documentation improvement
+
+    The `config.dot` diagram of the agent's configuration settings no
+    longer includes the deleted `developer_mode` option.  Thanks to
+    Yuichiro Kaneko for the contribution!
+
 ## v5.4.0
 
   * Capacity analysis for multi-threaded dispatchers

data/config.dot

@@ -1,7 +1,6 @@
 digraph AgentEnabled {
   node[color=green]
   "[agent_enabled]"
-  "[developer_mode]"
   "[monitor_mode]"
   "[slow_sql.explain_threshold]"
   "[slow_sql.stack_trace_threshold]"
@@ -198,7 +197,6 @@ digraph AgentEnabled {
   "Agent#validate_settings" -> "[validate_token]"
   "Agent#log_error" -> "Control#server"
   "Agent#monitoring?" -> "[monitor_mode]"
-  "Agent#check_trasaction_sampler_status" -> "[developer_mode]"
   "Agent#check_sql_sampler_status" -> "[slow_sql.enabled]"
   "Agent#check_sql_sampler_status" -> "[slow_sql.record_sql]"
   "Agent#check_sql_sampler_status" -> "[transaction_tracer.enabled]"
@@ -213,7 +211,6 @@ digraph AgentEnabled {
   "MethodTracer#remove_method_tracer" -> "[agent_enabled]"
 
   "Rails#init_config" -> "[agent_enabled]"
-  "Rails#init_config" -> "[developer_mode]"
 
   "ErrorCollector#initialize" -> "[error_collector.enabled]"
   "ErrorCollector#initialize" -> "[error_collector.capture_source]"
@@ -237,10 +234,6 @@ digraph AgentEnabled {
   "TransactionSampler#configure!" -> "[transaction_tracer.explain_threshold]"
   "TransactionSampler#configure!" -> "[transaction_tracer.explain_enabled]"
   "TransactionSampler#configure!" -> "[transaction_tracer.transaction_threshold]"
-  "TransactionSampler#configure!" -> "[developer_mode]"
-  "TransactionSampler#notice_push_scope" -> "[developer_mode]"
-  "TransactionSampler#capture_segment_trace" -> "[developer_mode]"
-  "TransactionSampler#store_segment_for_developer_mode" -> "[developer_mode]"
 
   "NoticedError#initialize" -> "[high_security]"
 

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -8,14 +8,15 @@ require 'json'
 require 'new_relic/agent/inbound_request_monitor'
 require 'new_relic/agent/transaction_state'
 require 'new_relic/agent/threading/agent_thread'
+require 'new_relic/agent/cross_app_payload'
 
 module NewRelic
   module Agent
     class CrossAppMonitor < InboundRequestMonitor
 
-      NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'
-      NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'
-      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'
+      NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'.freeze
+      NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'.freeze
+      NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
 
       NEWRELIC_ID_HEADER_KEY    = 'HTTP_X_NEWRELIC_ID'.freeze
       NEWRELIC_TXN_HEADER_KEY   = 'HTTP_X_NEWRELIC_TRANSACTION'.freeze
@@ -25,6 +26,15 @@ module NewRelic
         register_event_listeners(events)
       end
 
+      def path_hash(txn_name, seed)
+        rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
+        app_name   = NewRelic::Agent.config.app_names.first
+        identifier = "#{app_name};#{txn_name}"
+        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
+      end
+
+      private
+
       # Expected sequence of events:
       #   :before_call will save our cross application request id to the thread
       #   :after_call will write our response headers/metrics and clean up the thread
@@ -36,8 +46,13 @@ module NewRelic
           if id = decoded_id(env) and should_process_request?(id)
             state = NewRelic::Agent::TransactionState.tl_get
 
-            state.client_cross_app_id = id
-            save_referring_transaction_info(state, env)
+            if (transaction = state.current_transaction)
+              transaction_info = referring_transaction_info(state, env)
+
+              payload = CrossAppPayload.new(id, transaction, transaction_info)
+              transaction.cross_app_payload = payload
+            end
+
             CrossAppTracing.assign_intrinsic_transaction_attributes state
           end
         end
@@ -47,76 +62,38 @@ module NewRelic
 
           insert_response_header(state, env, headers)
         end
-
       end
 
-      def save_referring_transaction_info(state, request_headers)
+      def referring_transaction_info(state, request_headers)
         txn_header = request_headers[NEWRELIC_TXN_HEADER_KEY] or return
-        txn_info = deserialize_header(txn_header, NEWRELIC_TXN_HEADER)
-        state.referring_transaction_info = txn_info
-      end
-
-      def client_referring_transaction_guid(state)
-        info = state.referring_transaction_info or return nil
-        return info[0]
-      end
-
-      def client_referring_transaction_record_flag(state)
-        info = state.referring_transaction_info or return nil
-        return info[1]
-      end
-
-      def client_referring_transaction_trip_id(state)
-        info = state.referring_transaction_info or return nil
-        return info[2].is_a?(String) && info[2]
-      end
-
-      def client_referring_transaction_path_hash(state)
-        info = state.referring_transaction_info or return nil
-        return info[3].is_a?(String) && info[3]
+        deserialize_header(txn_header, NEWRELIC_TXN_HEADER)
       end
 
       def insert_response_header(state, request_headers, response_headers)
-        unless state.client_cross_app_id.nil?
-          txn = state.current_transaction
-          unless txn.nil?
-            txn.freeze_name_and_execute_if_not_ignored do
-              timings = state.timings
-              content_length = content_length_from_request(request_headers)
-
-              set_response_headers(state, response_headers, timings, content_length)
-            end
+        txn = state.current_transaction
+        unless txn.nil? || txn.cross_app_payload.nil?
+          txn.freeze_name_and_execute_if_not_ignored do
+            content_length = content_length_from_request(request_headers)
+            set_response_headers(txn, response_headers, content_length)
           end
         end
       end
 
       def should_process_request? id
-        return cross_app_enabled? && CrossAppTracing.trusts?(id)
-      end
-
-      def cross_app_enabled?
-        NewRelic::Agent::CrossAppTracing.cross_app_enabled?
+        CrossAppTracing.cross_app_enabled? && CrossAppTracing.trusts?(id)
       end
 
-      def set_response_headers(state, response_headers, timings, content_length)
-        response_headers[NEWRELIC_APPDATA_HEADER] = build_payload(state, timings, content_length)
-      end
+      def set_response_headers(transaction, response_headers, content_length)
+        payload = obfuscator.obfuscate(
+          ::JSON.dump(
+            transaction.cross_app_payload.as_json_array(content_length)))
 
-      def build_payload(state, timings, content_length)
-        payload = [
-          NewRelic::Agent.config[:cross_process_id],
-          timings.transaction_name,
-          timings.queue_time_in_seconds.to_f,
-          timings.app_time_in_seconds.to_f,
-          content_length,
-          state.request_guid
-        ]
-        payload = obfuscator.obfuscate(::JSON.dump(payload))
+        response_headers[NEWRELIC_APPDATA_HEADER] = payload
       end
 
       def decoded_id(request)
         encoded_id = request[NEWRELIC_ID_HEADER_KEY]
-        return "" if encoded_id.nil?
+        return "" if encoded_id.nil? || encoded_id.empty?
 
         obfuscator.deobfuscate(encoded_id)
       end
@@ -128,13 +105,6 @@ module NewRelic
       def hash_transaction_name(identifier)
         Digest::MD5.digest(identifier).unpack("@12N").first & 0xffffffff
       end
-
-      def path_hash(txn_name, seed)
-        rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
-        app_name   = NewRelic::Agent.config.app_names.first
-        identifier = "#{app_name};#{txn_name}"
-        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
-      end
     end
   end
 end

data/lib/new_relic/agent/cross_app_payload.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    class CrossAppPayload
+      attr_reader :id, :transaction, :referring_guid, :referring_trip_id, :referring_path_hash
+
+      def initialize(id, transaction, transaction_info)
+        @id                  = id
+        @transaction         = transaction
+
+        transaction_info ||= []
+        @referring_guid      = transaction_info[0]
+        # unused_flag        = transaction_info[1]
+        @referring_trip_id   = string_or_false_for(transaction_info[2])
+        @referring_path_hash = string_or_false_for(transaction_info[3])
+      end
+
+      def as_json_array(content_length)
+        queue_time_in_seconds = [transaction.queue_time.to_f, 0.0].max
+        start_time_in_seconds = [transaction.start_time.to_f, 0.0].max
+        app_time_in_seconds   = Time.now.to_f - start_time_in_seconds
+
+        [
+          NewRelic::Agent.config[:cross_process_id],
+          transaction.best_name,
+          queue_time_in_seconds.to_f,
+          app_time_in_seconds.to_f,
+          content_length,
+          transaction.guid
+        ]
+      end
+
+      private
+
+      def string_or_false_for(value)
+        value.is_a?(String) && value
+      end
+    end
+  end
+end

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -8,7 +8,6 @@ require 'json'
 module NewRelic
   module Agent
     module CrossAppTracing
-
       # The cross app response header for "outgoing" calls
       NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
 
@@ -22,6 +21,93 @@ module NewRelic
       NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
       NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
 
+      attr_accessor :is_cross_app_caller, :cross_app_payload, :cat_path_hashes
+
+      def is_cross_app_caller?
+        @is_cross_app_caller = false unless defined? @is_cross_app_caller
+        @is_cross_app_caller
+      end
+
+      def is_cross_app_callee?
+        cross_app_payload != nil
+      end
+
+      def is_cross_app?
+        is_cross_app_caller? || is_cross_app_callee?
+      end
+
+      def cat_trip_id
+        cross_app_payload && cross_app_payload.referring_trip_id || guid
+      end
+
+      def cat_path_hash
+        referring_path_hash = cat_referring_path_hash || '0'
+        seed = referring_path_hash.to_i(16)
+        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        record_cat_path_hash(result)
+        result
+      end
+
+      def add_message_cat_headers headers
+        self.is_cross_app_caller = true
+        CrossAppTracing.insert_message_headers headers,
+                                               guid,
+                                               cat_trip_id,
+                                               cat_path_hash,
+                                               raw_synthetics_header
+      end
+
+      private
+
+      def record_cat_path_hash(hash)
+        @cat_path_hashes ||= []
+        if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
+          @cat_path_hashes << hash
+        end
+      end
+
+      def cat_referring_path_hash
+        cross_app_payload && cross_app_payload.referring_path_hash
+      end
+
+      def append_cat_info(payload)
+        if (referring_guid = cross_app_payload && cross_app_payload.referring_guid)
+          payload[:referring_transaction_guid] = referring_guid
+        end
+
+        return unless include_guid?
+        payload[:guid] = guid
+
+        return unless is_cross_app?
+        trip_id             = cat_trip_id
+        path_hash           = cat_path_hash
+        referring_path_hash = cat_referring_path_hash
+
+        payload[:cat_trip_id]             = trip_id             if trip_id
+        payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
+
+        if path_hash
+          payload[:cat_path_hash] = path_hash
+
+          alternate_path_hashes = cat_path_hashes - [path_hash]
+          unless alternate_path_hashes.empty?
+            payload[:cat_alternate_path_hashes] = alternate_path_hashes
+          end
+        end
+      end
+
+      def assign_cross_app_intrinsics
+        attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
+        attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
+      end
+
+      def record_cross_app_metrics
+        if (id = cross_app_payload && cross_app_payload.id)
+          app_time_in_seconds = [Time.now.to_f - @start_time.to_f, 0.0].max
+          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
+        end
+      end
+
       ###############
       module_function
       ###############
@@ -127,16 +213,18 @@ module NewRelic
         valid_cross_app_id?(id) && trusts?(id)
       end
 
+      # From inbound request headers
       def assign_intrinsic_transaction_attributes state
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        return unless transaction = state.current_transaction
+        return unless (transaction       = state.current_transaction)
+        return unless (cross_app_payload = transaction.cross_app_payload)
 
-        if state.client_cross_app_id
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, state.client_cross_app_id)
+        if (cross_app_id = cross_app_payload.id)
+          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
         end
 
-        if referring_guid = state.referring_transaction_info && state.referring_transaction_info[0]
+        if (referring_guid = cross_app_payload.referring_guid)
           transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end

data/lib/new_relic/agent/external.rb

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/transaction/tracing'
 require 'new_relic/agent/cross_app_tracing'
+require 'new_relic/agent/cross_app_payload'
 
 module NewRelic
   module Agent
@@ -49,6 +50,7 @@ module NewRelic
       NON_HTTP_CAT_ID_HEADER  = 'NewRelicID'.freeze
       NON_HTTP_CAT_TXN_HEADER = 'NewRelicTransaction'.freeze
       NON_HTTP_CAT_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      NON_HTTP_CAT_CONTENT_LENGTH = -1
 
       # Process obfuscated +String+ indentifying a calling application and transaction that is also running a
       # New Relic agent and save information in current transaction for inclusion in a trace. The +String+ is
@@ -69,12 +71,12 @@ module NewRelic
           # handle/check ID
           #
           if id = rmd[NON_HTTP_CAT_ID_HEADER] and CrossAppTracing.trusted_valid_cross_app_id?(id)
-            state.client_cross_app_id = id
-
             # handle transaction info
             #
             if txn_info = rmd[NON_HTTP_CAT_TXN_HEADER]
-              state.referring_transaction_info = txn_info
+              payload = CrossAppPayload.new(id, transaction, txn_info)
+              transaction.cross_app_payload = payload
+
               CrossAppTracing.assign_intrinsic_transaction_attributes state
             end
 
@@ -108,30 +110,21 @@ module NewRelic
         return unless CrossAppTracing.cross_app_enabled?
 
         state = NewRelic::Agent::TransactionState.tl_get
-        if transaction = state.current_transaction and state.client_cross_app_id
+        return unless (transaction = state.current_transaction)
+        return unless (cross_app_payload = transaction.cross_app_payload)
 
-          # must freeze the name since we're responding with it
+        # must freeze the name since we're responding with it
+        #
+        transaction.freeze_name_and_execute_if_not_ignored do
+          # build response payload
           #
-          transaction.freeze_name_and_execute_if_not_ignored do
+          rmd = {
+            NewRelicAppData: cross_app_payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
+          }
 
-            # build response payload
-            #
-            rmd = {
-              NewRelicAppData: [
-                NewRelic::Agent.config[:cross_process_id],
-                state.timings.transaction_name,
-                state.timings.queue_time_in_seconds.to_f,
-                state.timings.app_time_in_seconds.to_f,
-                -1, # per non-HTTP CAT spec
-                state.request_guid
-              ]
-            }
-
-            # obfuscate the generated response metadata JSON
-            #
-            obfuscator.obfuscate ::JSON.dump(rmd)
-
-          end
+          # obfuscate the generated response metadata JSON
+          #
+          obfuscator.obfuscate ::JSON.dump(rmd)
         end
       rescue => e
         NewRelic::Agent.logger.error "error during get_response_metadata", e