newrelic-infinite_tracing 6.11.0.365

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc6db54323c4ae07d8db4e91bf7fc71b39290662585d0b65ac55cf60e5f91a4a
+  data.tar.gz: 928754820a8b4bea71bcb7bc1095058f2dba37bf0d53f7088642fbc67a0027f6
+SHA512:
+  metadata.gz: 12826887a68e0df4c28f2d7050909318a018f1ed8701b410b3a13a7750de45ee6375952ff8eaf46a56cbb5aac9f1ac5154b1ca14c7f1f38169c0219247bbfdd3
+  data.tar.gz: ea57b78c49205cc3b35af034d4de6f6ccb9d74b902aa2806f521307af9fa10e3fbd06eb5f5a9b1afbfe9f74107733947d870c6e5f240e8547465247e33ea88a3

data/.gitignore

@@ -0,0 +1,2 @@
+LICENSE
+CONTRIBUTING.md

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# New Relic Infinite Tracing for Ruby Agent Release Notes #
+
+  ## v6.11.0
+
+  * Initial Release!
+  * Implements gRPC protocol for communicating with Trace Observers

data/Gemfile

@@ -0,0 +1,12 @@
+# 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.
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec name: "newrelic-infinite_tracing"
+
+group :development do
+  gem 'newrelic_rpm', path: '..'
+end

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake/testtask'
+require "#{File.dirname(__FILE__)}/tasks/all.rb"
+
+task :default => :test
+
+task :console do
+  require 'pry'
+  require 'infinite_tracing'
+  ARGV.clear
+  Pry.start
+end
+
+Rake::TestTask.new do |t|
+  ROOT = File.join File.dirname(__FILE__)
+  $LOAD_PATH << ROOT
+
+  file_pattern = "#{ROOT}/**/*_test.rb"
+
+  t.libs << "#{ROOT}/test"
+  t.libs << "#{ROOT}/lib"
+  t.pattern = Array(file_pattern).join(",")
+  t.verbose =  ENV["VERBOSE"]
+end

data/lib/infinite_tracing.rb

@@ -0,0 +1,40 @@
+# 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.
+# frozen_string_literal: true
+
+require 'uri'
+
+require 'newrelic_rpm'
+
+NewRelic::Agent.logger.debug "Detected New Relic Infinite Tracing Gem"
+
+require 'infinite_tracing/version'
+require 'infinite_tracing/config'
+
+DependencyDetection.defer do
+  named :infinite_tracing
+
+  depends_on do
+    NewRelic::Agent::InfiniteTracing::Config.should_load?
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug "Loading New Relic Infinite Tracing Library"
+
+    require 'infinite_tracing/proto'
+
+    require 'infinite_tracing/constants'
+    require 'infinite_tracing/worker'
+    require 'infinite_tracing/record_status_handler'
+
+    require 'infinite_tracing/transformer'
+    require 'infinite_tracing/streaming_buffer'
+    require 'infinite_tracing/suspended_streaming_buffer'
+    require 'infinite_tracing/channel'
+    require 'infinite_tracing/connection'
+    require 'infinite_tracing/client'
+
+    require 'infinite_tracing/agent_integrations'
+  end
+end

data/lib/infinite_tracing/agent_integrations.rb

@@ -0,0 +1,20 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent
+  module InfiniteTracing
+    if Config.enabled? || Config.test_framework?
+      NewRelic::Agent.logger.debug "Integrating Infinite Tracer with Agent"
+
+      require_relative 'agent_integrations/agent'
+      require_relative 'agent_integrations/segment'
+      require_relative 'agent_integrations/datastore_segment'
+      require_relative 'agent_integrations/external_request_segment'
+
+    else
+      NewRelic::Agent.logger.debug "Skipped Integrating Infinite Tracer with Agent"
+    end
+  end
+end

data/lib/infinite_tracing/agent_integrations/agent.rb

@@ -0,0 +1,33 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent
+  NewRelic::Agent.logger.debug "Installing Infinite Tracer in Agent"
+  
+  Agent.class_eval do
+
+    def new_infinite_tracer
+      # We must start streaming in a thread or we block/deadlock the
+      # entire start up process for the Agent.
+      InfiniteTracing::Client.new.tap do |client| 
+        @infinite_tracer_thread = InfiniteTracing::Worker.new(:infinite_tracer) do 
+          NewRelic::Agent.logger.debug "Opening Infinite Tracer Stream with gRPC server"
+          client.start_streaming
+        end
+      end
+    end
+
+    def close_infinite_tracer
+      return unless @infinite_tracer_thread
+      @infinite_tracer_thread.join
+      @infinite_tracer_thread.stop
+      @infinite_tracer_thread = nil
+    end
+
+    def infinite_tracer
+      @infinite_tracer ||= new_infinite_tracer
+    end
+  end
+end

data/lib/infinite_tracing/agent_integrations/datastore_segment.rb

@@ -0,0 +1,17 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    class Transaction
+      class DatastoreSegment
+        def record_span_event
+          tracer = ::NewRelic::Agent.agent.infinite_tracer
+          tracer << Proc.new { SpanEventPrimitive.for_datastore_segment self }
+        end
+      end
+    end
+  end
+end

data/lib/infinite_tracing/agent_integrations/external_request_segment.rb

@@ -0,0 +1,17 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    class Transaction
+      class ExternalRequestSegment
+        def record_span_event
+          tracer = ::NewRelic::Agent.agent.infinite_tracer
+          tracer << Proc.new { SpanEventPrimitive.for_external_request_segment self }
+        end
+      end
+    end
+  end
+end

data/lib/infinite_tracing/agent_integrations/segment.rb

@@ -0,0 +1,22 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    class Transaction
+      class Segment
+
+        def segment_complete
+          record_span_event
+        end
+
+        def record_span_event
+          tracer = ::NewRelic::Agent.agent.infinite_tracer
+          tracer << Proc.new { SpanEventPrimitive.for_segment self }
+        end
+      end
+    end
+  end
+end

data/lib/infinite_tracing/channel.rb

@@ -0,0 +1,45 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent
+  module InfiniteTracing
+    class Channel
+
+      def stub
+        NewRelic::Agent.logger.debug "Infinite Tracer Opening Channel to #{host_and_port}"
+
+        Com::Newrelic::Trace::V1::IngestService::Stub.new \
+          host_and_port, 
+          credentials, 
+          channel_override: channel
+      end
+
+      def channel
+        GRPC::Core::Channel.new(host_and_port, settings, credentials)
+      end
+      
+      def credentials
+        if Config.local?
+          :this_channel_is_insecure 
+        else
+          # Uses system configured certificates by default
+          GRPC::Core::ChannelCredentials.new
+        end
+      end
+
+      def host_and_port
+        Config.trace_observer_host_and_port
+      end
+
+      def settings
+        {
+          'grpc.minimal_stack' => 1,
+          'grpc.enable_deadline_checking' => 0,
+        }
+      end
+
+    end
+  end
+end

data/lib/infinite_tracing/client.rb

@@ -0,0 +1,138 @@
+# 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.
+# frozen_string_literal: true
+
+# The Client class manages the streaming buffer with respect to the gRPC Connection.
+#
+# Restarting the client will cause a new connection to the gRPC server.
+# When the client is restarted, a new streaming buffer is started and contents of old
+# buffer are transferred to the new buffer.  
+#
+# Suspending the client will prevent the client from attempting to reconnect to the 
+# gRPC server, but will still continue to record the span events `seen` metric.
+module NewRelic::Agent
+  module InfiniteTracing
+    class Client
+      include Constants
+
+      def initialize
+        @suspended = false
+        @response_handler = nil
+        @lock = Mutex.new
+      end
+
+      def << segment
+        buffer << segment
+      end
+
+      # Transfers spans in streaming buffer from previous
+      # client (if any) and returns self (so we chain the call)
+      def transfer previous_client
+        return self unless previous_client
+        previous_client.buffer.transfer buffer
+        self
+      end
+
+      # provides the correct streaming buffer instance based on whether the
+      # client is currently suspended.
+      def new_streaming_buffer
+        buffer_class = suspended? ? SuspendedStreamingBuffer : StreamingBuffer
+        buffer_class.new Config.span_events_queue_size
+      end
+
+      def buffer
+        @buffer ||= new_streaming_buffer
+      end
+
+      def flush
+        buffer.flush_queue
+      end
+
+      # Turns camelcase base class name into upper snake case version of the name.
+      def formatted_class_name class_name
+        class_name = class_name.split(":")[-1]
+        formatted_class_name = (class_name.gsub!(/(.)([A-Z])/,'\1_\2') || class_name).upcase
+      end
+
+      # Literal codes are all mapped to unique class names, so we can deduce the
+      # name of the error to report in the metric from the error's class name.
+      def grpc_error_metric_name error
+        GRPC_ERROR_NAME_METRIC % formatted_class_name(error.class.name)
+      end
+
+      # Reports AND logs general response metric along with a more specific error metric
+      def record_error_metrics_and_log error
+        NewRelic::Agent.record_metric RESPONSE_ERROR_METRIC, 0.0
+        if error.is_a? GRPC::BadStatus
+          NewRelic::Agent.record_metric grpc_error_metric_name(error), 0.0
+        else
+          NewRelic::Agent.record_metric GRPC_OTHER_ERROR_METRIC, 0.0
+        end
+        NewRelic::Agent.logger.warn "gRPC response error received.", error
+      end
+
+      def handle_error error
+        record_error_metrics_and_log error
+
+        case error
+        when GRPC::Unavailable then restart
+        when GRPC::Unimplemented then suspend
+        else
+          # Set exponential backoff to false so we'll reconnect at periodic (15 second) intervals instead
+          start_streaming false
+        end
+      end
+
+      def suspended?
+        @suspended
+      end
+
+      # Places the client into suspended state whereby client will no longer attempt to 
+      # reconnect to the gRPC server nor will it attempt to send span events henceforth.
+      # The Suspended Streaming Buffer will be installed in this state.
+      def suspend
+        return if suspended?
+        @lock.synchronize do
+          @suspended = true
+          @buffer = new_streaming_buffer
+          NewRelic::Agent.logger.warn "The Trace Observer host signaled to suspend streaming span events. " \
+            "No more span events will be sent during this session."
+        end
+      end
+
+      def restart
+        @lock.synchronize do
+          Connection.reset
+          old_buffer = @buffer
+          @buffer = new_streaming_buffer
+          old_buffer.transfer @buffer
+        end
+        start_streaming
+      end
+
+      def stop
+        return unless @response_handler
+        @lock.synchronize do
+          @response_handler.stop
+          @response_handler = nil
+        end
+      end
+
+      def start_streaming exponential_backoff=true
+        return if suspended?
+        @lock.synchronize { @response_handler = record_spans exponential_backoff }
+      end
+
+      def record_spans exponential_backoff
+        RecordStatusHandler.new self, Connection.record_spans(self, buffer.enumerator, exponential_backoff)
+      end
+
+      def record_span_batches exponential_backoff
+        RecordStatusHandler.new self, Connection.record_span_batches(self, buffer.batch_enumerator, exponential_backoff)
+      end
+
+    end
+
+  end
+end

data/lib/infinite_tracing/config.rb

@@ -0,0 +1,115 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic::Agent
+  module InfiniteTracing
+    module Config
+      extend self
+
+      TRACE_OBSERVER_NOT_CONFIGURED_ERROR = "Trace Observer host not configured!"
+
+      # We only want to load the infinite tracing gem's files when
+      #   a) we're inside test framework and running tests
+      #   b) the trace observer host is configured
+      #
+      def should_load?
+        test_framework? || trace_observer_configured?
+      end
+
+      # Infinite Tracing support is enabled when the following conditions are true:
+      #   a) Distributed tracing is enabled in the agent, AND
+      #   b) Span events are enabled in the agent, both by client side configuration
+      #      AND the collect_span_events connect response field, AND
+      #   c) A Trace Observer host is configured by setting infinite_tracing.trace_observer.host.
+      def enabled?
+        distributed_tracing_enabled? && 
+        span_events_enabled? && 
+        trace_observer_configured?
+      end
+
+      # Distributed Tracing must be enabled for Infinite Tracing
+      def distributed_tracing_enabled?
+        NewRelic::Agent.config[:'distributed_tracing.enabled']
+      end
+
+      # Span Events must be enabled for Infinite Tracing
+      def span_events_enabled?
+        NewRelic::Agent.config[:'span_events.enabled']
+      end
+
+      # running locally is akin to communicating with the gRPC server with an 
+      # unencrypted channel.  Generally, this is _not_ allowed by the agent
+      # in normal use-cases.  The only known use-case for this is when 
+      # streaming under TEST conditions.
+      def local?
+        test_framework?
+      end
+
+      # removes the scheme and port from a host entry.
+      def without_scheme_or_port url
+        url.gsub(%r{^https?://|:\d+$}, '')
+      end
+
+      def trace_observer_host
+        without_scheme_or_port NewRelic::Agent.config[:'infinite_tracing.trace_observer.host']
+      end
+
+      # If the port is declared on the host entry, it overrides the port entry because otherwise
+      # we'd need to figure out if user supplied the port or if the default source config set
+      # the port.  To help with debugging configuration issues, we log whenever the port entry
+      # is overriden by the presence of the port on the host entry.
+      def port_from_host_entry
+        port_str = NewRelic::Agent.config[:'infinite_tracing.trace_observer.host'].scan(%r{:(\d+)$}).flatten
+        if port = (port_str[0] and port_str[0].to_i)
+          NewRelic::Agent.logger.warn(":'infinite_tracing.trace_observer.port' is ignored if present because :'infinite_tracing.trace_observer.host' specifies the port")
+          return port
+        end
+      end
+
+      # This is the port the trace observer is listening on.  It can be supplied as a suffix
+      # on the host entry or via the separate port entry.
+      def trace_observer_port
+        port_from_host_entry || NewRelic::Agent.config[:'infinite_tracing.trace_observer.port']
+      end
+
+      # The scheme is based on whether the Trace Observer is running locally or remotely. 
+      # Remote unsecure (unencypted) streaming is disallowed!
+      def trace_observer_scheme
+        local? ? NewRelic::HTTP : NewRelic::HTTPS
+      end
+
+      # The uniform resource identifier of the Trace Observer host constructed from all the parts.
+      def trace_observer_uri
+        if trace_observer_configured?
+          URI("#{trace_observer_scheme}://#{trace_observer_host_and_port}")
+        else
+          NewRelic::Agent.logger.error TRACE_OBSERVER_NOT_CONFIGURED_ERROR
+          raise TRACE_OBSERVER_NOT_CONFIGURED_ERROR
+        end
+      end
+
+      # returns host and port together expressed as +hostname:port+ string.
+      def trace_observer_host_and_port
+        "#{trace_observer_host}:#{trace_observer_port}"
+      end
+
+      # The maximum number of span events the Streaming Buffer can hold when buffering 
+      # to stream across the gRPC channel.
+      def span_events_queue_size
+        NewRelic::Agent.config[:'span_events.queue_size']
+      end
+
+      # Returns TRUE if we're running in a test environment
+      def test_framework?
+        NewRelic::Agent.config[:framework] == :test
+      end
+
+      # Infinite Tracing is configured when a non empty string is set as the host
+      def trace_observer_configured?
+        trace_observer_host != NewRelic::EMPTY_STR
+      end
+    end
+  end
+end