appoptics_apm 4.8.1 → 4.10.0

data/lib/appoptics_apm/inst/logger_formatter.rb

@@ -23,13 +23,14 @@ module AppOpticsAPM
         if current_trace.log?
           case msg
           when ::String
-            msg.strip.empty? ? msg : insert_before_empty_lines(msg, current_trace.for_log)
+            msg = msg.strip.empty? ? msg : insert_before_empty_lines(msg, current_trace.for_log)
           when ::Exception
             # conversion to String copied from Logger::Formatter private method #msg2str
-            "#{msg.message} (#{msg.class}) #{current_trace.for_log}\n" <<
-              (msg.backtrace || []).join("\n")
+            msg = ("#{msg.message} (#{msg.class}) #{current_trace.for_log}\n" <<
+              (msg.backtrace || []).join("\n"))
           end
         end
+        msg
       end
 
       def insert_before_empty_lines(msg, for_log)

data/lib/appoptics_apm/inst/rack.rb

@@ -27,30 +27,30 @@ if AppOpticsAPM.loaded
       end
 
       def call(env)
-        incoming = AppOpticsAPM::Context.isValid
 
         # In the case of nested Ruby apps such as Grape inside of Rails
         # or Grape inside of Grape, each app has it's own instance
         # of rack middleware. We want to avoid tracing rack more than once
         return @app.call(env) if AppOpticsAPM.tracing? && AppOpticsAPM.layer == :rack
 
+        incoming = AppOpticsAPM::Context.isValid
         AppOpticsAPM.transaction_name = nil
 
         url = env['PATH_INFO']
+        options = AppOpticsAPM::XTraceOptions.new(env['HTTP_X_TRACE_OPTIONS'], env['HTTP_X_TRACE_OPTIONS_SIGNATURE'])
         xtrace = AppOpticsAPM::XTrace.valid?(env['HTTP_X_TRACE']) ? (env['HTTP_X_TRACE']) : nil
-
-        settings = AppOpticsAPM::TransactionSettings.new(url, xtrace)
-
-        # AppOpticsAPM.logger.warn "%%% FILTER: #{settings} %%%"
+        settings = AppOpticsAPM::TransactionSettings.new(url, xtrace, options)
 
         response =
           propagate_xtrace(env, settings, xtrace) do
-            sample(env, settings) do
+            sample(env, settings, options) do
               AppOpticsAPM::TransactionMetrics.metrics(env, settings) do
                 @app.call(env)
               end
             end
           end || [500, {}, nil]
+        options.add_response_header(response[1], settings)
+
         AppOpticsAPM::Context.clear unless incoming
         response
       rescue
@@ -66,7 +66,7 @@ if AppOpticsAPM.loaded
 
       private
 
-      def collect(env, settings)
+      def collect(env)
         req = ::Rack::Request.new(env)
         report_kvs = {}
 
@@ -84,8 +84,6 @@ if AppOpticsAPM.loaded
 
           report_kvs[:URL] = AppOpticsAPM::Config[:rack][:log_args] ? ::CGI.unescape(req.fullpath) : ::CGI.unescape(req.path)
           report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:rack][:collect_backtraces]
-          report_kvs[:SampleRate]        = settings.rate
-          report_kvs[:SampleSource]      = settings.source
 
           # Report any request queue'ing headers.  Report as 'Request-Start' or the summed Queue-Time
           report_kvs[:'Request-Start']     = env['HTTP_X_REQUEST_START']    if env.key?('HTTP_X_REQUEST_START')
@@ -126,11 +124,13 @@ if AppOpticsAPM.loaded
         [status, headers, response]
       end
 
-      def sample(env, settings)
+      def sample(env, settings, options)
         xtrace = env['HTTP_X_TRACE']
         if settings.do_sample
           begin
-            report_kvs = collect(env, settings)
+            report_kvs = collect(env)
+            settings.add_kvs(report_kvs)
+            options&.add_kvs(report_kvs, settings)
 
             AppOpticsAPM::API.log_start(:rack, xtrace, report_kvs, settings)
 

data/lib/appoptics_apm/oboe_init_options.rb

@@ -8,7 +8,7 @@ module AppOpticsAPM
   class OboeInitOptions
     include Singleton
 
-    attr_reader :reporter, :host, :service_name  # exposing these mainly for testing
+    attr_reader :reporter, :host, :service_name, :ec2_md_timeout  # exposing these mainly for testing
 
     # TODO decide if these globals are useful when testing
     # OBOE_HOSTNAME_ALIAS = 0
@@ -69,6 +69,8 @@ module AppOpticsAPM
       @token_bucket_rate = (ENV['APPOPTICS_TOKEN_BUCKET_RATE'] || -1).to_i
       # use single files in file reporter for each event
       @file_single = (ENV['APPOPTICS_REPORTER_FILE_SINGLE'].to_s.downcase == 'true') ? 1 : 0
+      # timeout for ec2 metadata
+      @ec2_md_timeout = read_and_validate_ec2_md_timeout
     end
 
     def re_init # for testing with changed ENV vars
@@ -94,7 +96,8 @@ module AppOpticsAPM
         @histogram_precision,
         @token_bucket_capacity,
         @token_bucket_rate,
-        @file_single
+        @file_single,
+        @ec2_md_timeout
       ]
     end
 
@@ -108,7 +111,8 @@ module AppOpticsAPM
 
       reporter = ENV['APPOPTICS_REPORTER'] || 'ssl'
       # override with 'file', e.g. when running tests
-      reporter = 'file' if ENV.key?('APPOPTICS_GEM_TEST')
+      # changed my mind => set the right reporter in the env when running tests !!!
+      # reporter = 'file' if ENV.key?('APPOPTICS_GEM_TEST')
 
       host = ''
       case reporter
@@ -121,6 +125,7 @@ module AppOpticsAPM
         # ____ AppOpticsAPM::Config[:reporter_host] and
         # ____ AppOpticsAPM::Config[:reporter_port] were moved here from
         # ____ oboe_metal.rb and are not documented anywhere
+        # ____ udp is for internal use only
       when 'null'
         host = ''
       end
@@ -148,7 +153,7 @@ module AppOpticsAPM
     end
 
     def validate_token(token)
-      if (token !~ /^[0-9a-fA-F]{64}|[0-9a-zA-Z_\-]{71}$/)
+      if (token !~ /^[0-9a-fA-F]{64}|[0-9a-zA-Z_-]{71}$/) && ENV['APPOPTICS_COLLECTOR'] != "sslcollector:12222"
         masked = "#{token[0..3]}...#{token[-4..-1]}"
         AppOpticsAPM.logger.error "[appoptics_apm/oboe_options] APPOPTICS_SERVICE_KEY problem. API Token in wrong format. Masked token: #{masked}"
         return false
@@ -158,6 +163,7 @@ module AppOpticsAPM
     end
 
     def validate_transform_service_name(service_name)
+      service_name = 'test_ssl_collector' if ENV['APPOPTICS_COLLECTOR'] == "sslcollector:12222"
       if service_name.empty?
         AppOpticsAPM.logger.error "[appoptics_apm/oboe_options] APPOPTICS_SERVICE_KEY problem. Service Name is missing"
         return false
@@ -175,6 +181,13 @@ module AppOpticsAPM
       @service_name = service_name # instance variable used in testing
       true
     end
+
+    def read_and_validate_ec2_md_timeout
+      timeout = (ENV['APPOPTICS_EC2_METADATA_TIMEOUT'] || AppOpticsAPM::Config[:ec2_metadata_timeout])
+      return 1000 unless timeout.is_a?(Integer) || timeout =~ /^\d+$/
+      timeout = timeout.to_i
+      return timeout.between?(0, 3000) ? timeout : 1000
+    end
   end
 end
 

data/lib/appoptics_apm/sdk/tracing.rb

@@ -32,6 +32,7 @@ module AppOpticsAPM
     # * +AppOpticsAPM::SDK.start_trace+
     # * +AppOpticsAPM::SDK.start_trace_with_target+
     # * +AppOpticsAPM::SDK.trace+
+    # * +AppOpticsAPM::SDK.trace_method+
     # * +AppOpticsAPM::SDK.tracing?+
     #
     # === Example:
@@ -207,6 +208,123 @@ module AppOpticsAPM
         result
       end
 
+      ##
+      # Add tracing to a given method
+      #
+      # This instruments the given method so that every time it is called it
+      # will create a span depending on the current context.
+      #
+      # The method can be of any (accessible) type (instance, singleton,
+      # private, protected etc.).
+      #
+      # The motivating use case for this is MetalController methods in Rails,
+      # which can't be auto-instrumented.
+      #
+      # === Arguments:
+      # * +klass+  - The module/class the method belongs to.
+      # * +method+ - The method name as symbol
+      # * +config+   - (optional) possible keys are:
+      #              :name the name of the span (default: the method name)
+      #              :backtrace true/false (default: false) if true the backtrace will be added to the space
+      # * +opts+    - (optional) hash containing key/value pairs that will be reported with this span.
+      #
+      # === Example:
+      #
+      #   module ExampleModule
+      #     def do_sum(a, b)
+      #       a + b
+      #     end
+      #   end
+      #
+      #  AppOpticsAPM::SDK.trace_method(ExampleModule, :do_sum, {name: 'computation', backtrace: true}, { CustomKey: "some_info"})
+      #
+      def trace_method(klass, method, config = {}, opts = {})
+        # If we're on an unsupported platform (ahem Mac), just act
+        # like we did something to nicely play the no-op part.
+        return true unless AppOpticsAPM.loaded
+
+        if !klass.is_a?(Module)
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] trace_method: Not sure what to do with #{klass}.  Send a class or module."
+          return false
+        end
+
+        if method.is_a?(String)
+          method = method.to_sym
+        elsif !method.is_a?(Symbol)
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] trace_method: Not sure what to do with #{method}.  Send a string or symbol for method."
+          return false
+        end
+
+        instance_method = klass.instance_methods.include?(method) || klass.private_instance_methods.include?(method)
+        class_method = klass.singleton_methods.include?(method)
+
+        # Make sure the request klass::method exists
+        if !instance_method && !class_method
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] trace_method: Can't instrument #{klass}.#{method} as it doesn't seem to exist."
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] #{__FILE__}:#{__LINE__}"
+          return false
+        end
+
+        # Strip '!' or '?' from method if present
+        safe_method_name = method.to_s.chop if method.to_s =~ /\?$|\!$/
+        safe_method_name ||= method
+
+        without_appoptics = "#{safe_method_name}_without_appoptics"
+        with_appoptics    = "#{safe_method_name}_with_appoptics"
+
+        # Check if already profiled
+        if instance_method && klass.instance_methods.include?(with_appoptics.to_sym) ||
+          class_method && klass.singleton_methods.include?(with_appoptics.to_sym)
+          AppOpticsAPM.logger.warn "[appoptics_apm/error] trace_method: #{klass}::#{method} already instrumented.\n#{__FILE__}:#{__LINE__}"
+          return false
+        end
+
+        report_kvs = opts.dup
+        if defined?(::AbstractController::Base) && klass.ancestors.include?(::AbstractController::Base)
+          report_kvs[:Controller] = klass.to_s
+          report_kvs[:Action] = method.to_s
+        else
+          klass.is_a?(Class) ? report_kvs[:Class] = klass.to_s : report_kvs[:Module] = klass.to_s
+          report_kvs[:MethodName] = safe_method_name
+        end
+        backtrace = config[:backtrace]
+
+        span = config[:name] || method
+        if instance_method
+          klass.class_eval do
+            define_method(with_appoptics) do |*args, &block|
+              # if this is a rails controller we want to set the transaction for the outbound metrics
+              if report_kvs[:Controller] && defined?(request) && defined?(request.env)
+                request.env['appoptics_apm.controller'] = report_kvs[:Controller]
+                request.env['appoptics_apm.action'] = report_kvs[:Action]
+              end
+
+              AppOpticsAPM::SDK.trace(span, report_kvs) do
+                report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace(2) if backtrace
+                send(without_appoptics, *args, &block)
+              end
+            end
+
+            alias_method without_appoptics, method.to_s
+            alias_method method.to_s, with_appoptics
+          end
+        elsif class_method
+          klass.define_singleton_method(with_appoptics) do |*args, &block|
+            AppOpticsAPM::SDK.trace(span, report_kvs) do
+              report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace(2) if backtrace
+              send(without_appoptics, *args, &block)
+            end
+          end
+
+          klass.singleton_class.class_eval do
+            alias_method without_appoptics, method.to_s
+            alias_method method.to_s, with_appoptics
+          end
+        end
+        true
+      end
+
+      ##
       # Provide a custom transaction name
       #
       # The AppOpticsAPM gem tries to create meaningful transaction names from controller+action

data/lib/appoptics_apm/support/transaction_metrics.rb

@@ -15,6 +15,7 @@ module AppOpticsAPM
       def metrics(env, settings)
         if settings.do_metrics
           req = ::Rack::Request.new(env)
+          # TODO rails 3x is not supported anymore ...
           url = req.url   # saving it here because rails3.2 overrides it when there is a 500 error
           start = Time.now
 

data/lib/appoptics_apm/support/transaction_settings.rb

@@ -6,14 +6,9 @@ AO_TRACING_ENABLED = 1
 AO_TRACING_DISABLED = 0
 AO_TRACING_UNSET = -1
 
-AO_TRACING_DECISIONS_TRACING_DISABLED = -2
-AO_TRACING_DECISIONS_XTRACE_NOT_SAMPLED = -1
 AO_TRACING_DECISIONS_OK = 0
-AO_TRACING_DECISIONS_NULL_OUT = 1
-AO_TRACING_DECISIONS_NO_CONFIG = 2
-AO_TRACING_DECISIONS_REPORTER_NOT_READY = 3
-AO_TRACING_DECISIONS_NO_VALID_SETTINGS = 4
-AO_TRACING_DECISIONS_QUEUE_FULL = 5
+
+OBOE_SETTINGS_UNSET = -1
 
 module AppOpticsAPM
   ##
@@ -21,13 +16,15 @@ module AppOpticsAPM
   #
   class TransactionSettings
 
-    attr_accessor :do_metrics, :do_sample
-    attr_reader   :do_propagate, :rate, :source
+    attr_accessor :do_sample, :do_metrics
+    attr_reader   :auth_msg, :do_propagate, :status_msg, :type, :source, :rate, :xtrace
+                  #, :status
 
-    def initialize(url = nil, xtrace = '')
+    def initialize(url = '', xtrace = '', options = nil)
       @do_metrics = false
       @do_sample = false
       @do_propagate = true
+      @xtrace = xtrace || ''
       tracing_mode = AO_TRACING_ENABLED
 
       if AppOpticsAPM::Context.isValid
@@ -46,14 +43,23 @@ module AppOpticsAPM
         tracing_mode = AO_TRACING_DISABLED
       end
 
-      args = [xtrace || '']
+      args = [@xtrace]
       args << tracing_mode
-      args << AppOpticsAPM::Config[:sample_rate] if AppOpticsAPM::Config[:sample_rate]&. >= 0
+      args << (AppOpticsAPM::Config[:sample_rate] || OBOE_SETTINGS_UNSET)
+
+      if options && (options.options || options.signature)
+        args << (options.trigger_trace ? 1 : 0)
+        args << (trigger_tracing_mode_disabled? ? 0 : 1)
+        args << options.options
+        args << options.signature
+        args << options.timestamp
+      end
 
-      metrics, sample, @rate, @source, return_code = AppOpticsAPM::Context.getDecisions(*args)
+      metrics, sample, @rate, @source, @type, @auth, @status_msg, @auth_msg, @status =
+        AppOpticsAPM::Context.getDecisions(*args)
 
-      if return_code > AO_TRACING_DECISIONS_OK
-        AppOpticsAPM.logger.warn "[appoptics-apm/sample] Problem getting the sampling decisions, code: #{return_code}"
+      if @status > AO_TRACING_DECISIONS_OK
+        AppOpticsAPM.logger.warn "[appoptics-apm/sample] Problem getting the sampling decisions: #{@status_msg} code: #{@status}"
       end
 
       @do_metrics = metrics > 0
@@ -64,6 +70,20 @@ module AppOpticsAPM
       "do_propagate: #{do_propagate}, do_sample: #{do_sample}, do_metrics: #{do_metrics} rate: #{rate}, source: #{source}"
     end
 
+    def add_kvs(kvs)
+      kvs[:SampleRate] = @rate
+      kvs[:SampleSource] = @source
+    end
+
+    def triggered_trace?
+      @type == 1
+    end
+
+    def auth_ok?
+      # @auth is undefined if initialize is called with an existing context
+      !@auth || @auth < 1
+    end
+
     private
 
     ##
@@ -103,6 +123,11 @@ module AppOpticsAPM
       false
     end
 
+    def trigger_tracing_mode_disabled?
+      AppOpticsAPM::Config[:trigger_tracing_mode] &&
+        AppOpticsAPM::Config[:trigger_tracing_mode] == :disabled
+    end
+
     ##
     # asset?
     #

data/lib/appoptics_apm/support/x_trace_options.rb

@@ -0,0 +1,110 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+
+module AppOpticsAPM
+  class XTraceOptions
+
+    attr_reader :options, :signature, :trigger_trace, :timestamp
+    attr_reader :pd_keys, :custom_kvs, :ignored # used in tests
+    ##
+    # Params:
+    # +options+ : An X-Trace-Options @options string
+    # +signature+ : hmac signature to pass on for verification
+    #
+    # populates:
+    # - @force_trace (true|false)
+    # - @app_id (as given by Pingdom)
+    # - @probe_id (as given by Pingdom)
+    # - @loc (2 characters given by Pingdom)
+    # - @custom_kvs (hash)
+    # - @ignored (array)
+    #
+    # split it up by ';' separator
+    # kv assignment by '='
+    # currently valid keys:
+    # - force_trace (valid: 0,1) unless we use just a kv
+    # - application_id (format defined by pingdom (no validation))
+    # - probe_id
+    # - custom_* (';=' not allowed in key), value (validate max. length)
+    # - ts (unix timestamp)
+    # - other keys will be reported in the response options as ignored
+
+    def initialize(options, signature = nil)
+      @options = options.dup
+      @signature = signature.dup
+      @trigger_trace = false
+      @custom_kvs = {}
+      @pd_keys = nil
+      @ignored = []
+      @timestamp = 0
+
+      options&.split(/;+/)&.each do |val|
+        k = val.split('=', 2)
+
+        next unless k[0] # it can be nil, eg when the header starts with ';'
+
+        k[0]&.strip!
+        case k[0]
+        when 'trigger-trace'
+          if k[1]
+            @ignored << 'trigger-trace'
+          else
+            @trigger_trace = true
+          end
+        when 'pd-keys'
+          if @pd_keys
+            AppOpticsAPM.logger.info "[appoptics_apm/x-trace-options] Duplicate key: #{k[0]}"
+          else
+            @pd_keys = k[1].strip
+          end
+        when /^custom-[^\s]*$/
+          if @custom_kvs[k[0]]
+            AppOpticsAPM.logger.info "[appoptics_apm/x-trace-options] Duplicate key: #{k[0]}"
+          else
+            @custom_kvs[k[0]] = k[1].strip
+          end
+        when 'ts'
+          if @timestamp > 0
+            AppOpticsAPM.logger.info "[appoptics_apm/x-trace-options] Duplicate key: #{k[0]}"
+          else
+            @timestamp = k[1].to_i
+          end
+        else
+          @ignored << k[0]
+        end
+      end
+      unless @ignored.empty?
+        msg = "[appoptics_apm/x-trace-options] Some keys were ignored: #{@ignored.join(',' )}"
+        AppOpticsAPM.logger.info(msg)
+      end
+    end
+
+    def add_kvs(kvs, settings)
+      return unless settings.auth_ok?
+
+      @custom_kvs.each { |k,v| kvs[k] = v } unless @custom_kvs.empty?
+      kvs['PDKeys'] = @pd_keys if @pd_keys
+      kvs['TriggeredTrace'] = true if settings.triggered_trace?
+    end
+
+    def add_response_header(headers, settings)
+      return unless options
+
+      response = []
+      response << "auth=#{settings.auth_msg}" if @signature
+      if settings.auth_ok?
+        if @trigger_trace
+          trigger_msg = !settings.xtrace.empty? && settings.type == 0 ? 'ignored' : settings.status_msg
+        else
+          trigger_msg = 'not-requested'
+        end
+        response << "trigger-trace=#{trigger_msg}"
+        response << "ignored=#{@ignored.join(',')}" unless @ignored.empty?
+      end
+
+      headers['X-Trace-Options-Response'] = response.join(';')
+    end
+
+  end
+end