appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/api/logging.rb

@@ -0,0 +1,381 @@
+#--
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+# Make sure Set is loaded if possible.
+begin
+  require 'set'
+rescue LoadError
+  class Set; end # :nodoc:
+end
+
+
+module AppOpticsAPM
+  module API
+    ##
+    # This modules provides the X-Trace logging facilities.
+    #
+    # These are the lower level methods, please see AppOpticsAPM::SDK
+    # for the higher level methods
+    #
+    # If using these directly make sure to always match a start/end and entry/exit to
+    # avoid broken traces.
+    module Logging
+      @@ints_or_nil = [Integer, Float, NilClass, String]
+      @@ints_or_nil << Fixnum unless RUBY_VERSION >= '2.4'
+
+      ##
+      # Public: Report an event in an active trace.
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +label+ - The label for the reported event. See SDK documentation for reserved labels and usage.
+      # * +opts+  - A hash containing key/value pairs that will be reported along with this event (optional).
+      # * +event+ - An event to be used instead of generating a new one (see also start_trace_with_target)
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log('logical_layer', 'entry')
+      #   AppOpticsAPM::API.log('logical_layer', 'info', { :list_length => 20 })
+      #   AppOpticsAPM::API.log('logical_layer', 'exit')
+      #
+      # Returns nothing.
+      def log(layer, label, opts = {}, event = nil)
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+
+        event ||= AppOpticsAPM::Context.createEvent
+        log_event(layer, label, event, opts)
+      end
+
+      ##
+      # Public: Report an exception.
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +exception+ - The exception to report, responds to :message and :backtrace(optional)
+      # * +opts+ - Custom params if you want to log extra information
+      #
+      # ==== Example
+      #
+      #   begin
+      #     my_iffy_method
+      #   rescue Exception => e
+      #     AppOpticsAPM::API.log_exception('rails', e, { user: user_id })
+      #     raise
+      #   end
+      #
+      # Returns nothing.
+      def log_exception(layer, exception, opts = {})
+        return AppOpticsAPM::Context.toString if !AppOpticsAPM.tracing? || exception.instance_variable_get(:@exn_logged)
+
+        unless exception
+          AppOpticsAPM.logger.debug '[appoptics_apm/debug] log_exception called with nil exception'
+          return AppOpticsAPM::Context.toString
+        end
+
+        exception.message << exception.class.name if exception.message.length < 4
+        opts.merge!(:Spec => 'error',
+                    :ErrorClass => exception.class.name,
+                    :ErrorMsg => exception.message)
+
+        if exception.respond_to?(:backtrace) && exception.backtrace
+          opts.merge!(:Backtrace => exception.backtrace.join("\r\n"))
+        end
+
+        exception.instance_variable_set(:@exn_logged, true)
+        log(layer, :error, opts)
+      end
+
+      ##
+      # Public: Start a trace depending on TransactionSettings
+      # or decide whether or not to start a trace, and report an entry event
+      # appropriately.
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +xtrace+ - An xtrace metadata string, or nil.  Used for cross-application tracing.
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event (optional).
+      # * +settings+ - An instance of TransactionSettings
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log_start(:layer_name, nil, { :id => @user.id })
+      #
+      # Returns an xtrace metadata string if we are tracing
+      #
+      def log_start(layer, xtrace = nil, opts = {}, settings = nil)
+        return unless AppOpticsAPM.loaded
+
+        # check if tracing decision is already in effect and a Context created
+        return log_entry(layer, opts) if AppOpticsAPM::Context.isValid
+
+        # This is a bit ugly, but here is the best place to reset the layer_op thread local var.
+        AppOpticsAPM.layer_op = nil
+
+        xtrace = nil unless AppOpticsAPM::XTrace.valid?(xtrace)
+
+        settings ||= AppOpticsAPM::TransactionSettings.new(nil, xtrace)
+
+        if settings.do_sample
+          opts[:SampleRate]        = settings.rate
+          opts[:SampleSource]      = settings.source
+
+          AppOpticsAPM::XTrace.set_sampled(xtrace) if xtrace
+          event = create_start_event(xtrace)
+          log_event(layer, :entry, event, opts)
+        else
+          create_nontracing_context(xtrace)
+          AppOpticsAPM::Context.toString
+        end
+      end
+
+      ##
+      # Public: Report an exit event and potentially clear the tracing context.
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event (optional).
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log_end(:layer_name, { :id => @user.id })
+      #
+      # Returns an xtrace metadata string if we are tracing
+      #
+      def log_end(layer, opts = {}, event = nil)
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+
+        event ||= AppOpticsAPM::Context.createEvent
+        log_event(layer, :exit, event, opts)
+      ensure
+        # FIXME has_incoming_context commented out, it has importance for JRuby only but breaks Ruby tests
+        AppOpticsAPM::Context.clear # unless AppOpticsAPM.has_incoming_context?
+        AppOpticsAPM.transaction_name = nil
+      end
+
+      ##
+      # Public: Log an entry event
+      #
+      # A helper method to create and log an entry event
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event (optional).
+      # * +op+ - To identify the current operation being traced.  Used to avoid double tracing recursive calls.
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log_entry(:layer_name, { :id => @user.id })
+      #
+      # Returns an xtrace metadata string if we are tracing
+      #
+      def log_entry(layer, opts = {}, op = nil) #, event = nil)
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+
+        if op
+          # check if re-entry but also add op to list for log_exit
+          re_entry = AppOpticsAPM.layer_op&.last == op.to_sym
+          AppOpticsAPM.layer_op = (AppOpticsAPM.layer_op || []) << op.to_sym
+          return AppOpticsAPM::Context.toString if re_entry
+        end
+
+        event ||= AppOpticsAPM::Context.createEvent
+        log_event(layer, :entry, event, opts)
+      end
+
+      ##
+      # Public: Log an info event
+      #
+      # A helper method to create and log an info event
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event (optional).
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log_info(:layer_name, { :id => @user.id })
+      #
+      # Returns an xtrace metadata string if we are tracing
+      #
+      def log_info(layer, opts = {})
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+
+        opts[:Spec] = 'info'
+        log_event(layer, :info, AppOpticsAPM::Context.createEvent, opts)
+      end
+
+      ##
+      # Public: Log an exit event
+      #
+      # A helper method to create and log an exit event
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +opts+  - A hash containing key/value pairs that will be reported along with this event (optional).
+      # * +op+    - Used to avoid double tracing recursive calls, needs to be the same in +log_exit+ that corresponds to a
+      #   +log_entry+
+      #
+      # ==== Example
+      #
+      #   AppOpticsAPM::API.log_exit(:layer_name, { :id => @user.id })
+      #
+      # Returns an xtrace metadata string  if we are tracing
+      def log_exit(layer, opts = {}, op = nil)
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+
+        if op
+          if AppOpticsAPM.layer_op&.last == op.to_sym
+            AppOpticsAPM.layer_op.pop
+          else
+            AppOpticsAPM.logger.warn "[ruby/logging] op parameter of exit event doesn't correspond to an entry event op"
+          end
+          # check if the next op is the same, don't log event if so
+          return AppOpticsAPM::Context.toString if AppOpticsAPM.layer_op&.last == op.to_sym
+        end
+
+        log_event(layer, :exit, AppOpticsAPM::Context.createEvent, opts)
+      end
+
+      ##
+      # Public: Log an exit event from multiple requests
+      #
+      # A helper method to create and log an info event
+      # If we return from a request that faned out multiple requests
+      # we can add the collected X-Traces to the exit event
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +traces+ - An array with X-Trace strings returned from the requests
+      #
+      def log_multi_exit(layer, traces)
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
+        task_id = AppOpticsAPM::XTrace.task_id(AppOpticsAPM::Context.toString)
+        event = AppOpticsAPM::Context.createEvent
+        traces.each do |trace|
+          event.addEdgeStr(trace) if AppOpticsAPM::XTrace.task_id(trace) == task_id
+        end
+        log_event(layer, :exit, event)
+      end
+
+      ##
+      #:nodoc:
+      # Internal: Reports agent init to the collector
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event
+      def log_init(layer = :rack, opts = {})
+        context = AppOpticsAPM::Metadata.makeRandom
+        return AppOpticsAPM::Context.toString unless context.isValid
+
+        event = context.createEvent
+        event.addInfo(APPOPTICS_STR_LAYER, layer.to_s)
+        event.addInfo(APPOPTICS_STR_LABEL, 'single')
+        opts.each do |k, v|
+          event.addInfo(k, v.to_s)
+        end
+
+        AppOpticsAPM::Reporter.sendStatus(event, context)
+        AppOpticsAPM::Context.toString
+      end
+
+      private
+
+      ##
+      #:nodoc:
+      # @private
+      # Internal: Report an event.
+      #
+      # ==== Arguments
+      #
+      # * +layer+ - The layer the reported event belongs to
+      # * +label+ - The label for the reported event.  See API documentation for reserved labels and usage.
+      # * +event+ - The pre-existing AppOpticsAPM context event.  See AppOpticsAPM::Context.createEvent
+      # * +opts+ - A hash containing key/value pairs that will be reported along with this event (optional).
+      #
+      # ==== Example
+      #
+      #   entry = AppOpticsAPM::Context.createEvent
+      #   AppOpticsAPM::API.log_event(:layer_name, 'entry',  entry_event, { :id => @user.id })
+      #
+      #   exit_event = AppOpticsAPM::Context.createEvent
+      #   exit_event.addEdge(entry.getMetadata)
+      #   AppOpticsAPM::API.log_event(:layer_name, 'exit',  exit_event, { :id => @user.id })
+      #
+      def log_event(layer, label, event, opts = {})
+        event.addInfo(APPOPTICS_STR_LAYER, layer.to_s.freeze) if layer
+        event.addInfo(APPOPTICS_STR_LABEL, label.to_s.freeze)
+
+        AppOpticsAPM.layer = layer.to_sym if label == :entry
+        AppOpticsAPM.layer = nil          if label == :exit
+
+        opts.each do |k, v|
+          value = nil
+
+          next unless valid_key? k
+
+          if @@ints_or_nil.include?(v.class)
+            value = v
+          elsif v.class == Set
+            value = v.to_a.to_s
+          else
+            value = v.to_s if v.respond_to?(:to_s)
+          end
+
+          begin
+            event.addInfo(k.to_s, value)
+          rescue ArgumentError => e
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] Couldn't add event KV: #{k} => #{v.class}"
+            AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{e.message}"
+          end
+        end if !opts.nil? && opts.any?
+
+        AppOpticsAPM::Reporter.sendReport(event)
+        AppOpticsAPM::Context.toString
+      end
+
+      def create_start_event(xtrace = nil)
+        if AppOpticsAPM::XTrace.sampled?(xtrace)
+          md = AppOpticsAPM::Metadata.fromString(xtrace)
+          AppOpticsAPM::Context.fromString(xtrace)
+          md.createEvent
+        else
+          md = AppOpticsAPM::Metadata.makeRandom(true)
+          AppOpticsAPM::Context.set(md)
+          AppOpticsAPM::Event.startTrace(md)
+        end
+      end
+
+      public
+
+      def create_nontracing_context(xtrace)
+        if AppOpticsAPM::XTrace.valid?(xtrace)
+          # continue valid incoming xtrace
+          # use it for current context, ensuring sample bit is not set
+          AppOpticsAPM::XTrace.unset_sampled(xtrace)
+          AppOpticsAPM::Context.fromString(xtrace)
+        else
+          # discard invalid incoming xtrace
+          # create a new context, ensuring sample bit not set
+          md = AppOpticsAPM::Metadata.makeRandom(false)
+          AppOpticsAPM::Context.fromString(md.toString)
+        end
+      end
+
+      # need to set the context to public, otherwise the following `extends` will be private in api.rb
+      public
+
+    end
+  end
+end

data/lib/appoptics_apm/api/memcache.rb

@@ -0,0 +1,37 @@
+#--
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+# TODO remove Memcache from API and into some Util module to be included in Modules that need
+# ____ these methods
+module AppOpticsAPM
+  module API
+    ##
+    # Utility methods for the Memcache instrumentation
+    # currently used by dalli and memcached
+    module Memcache #:nodoc:
+      MEMCACHE_OPS = %w(add append cas decr decrement delete fetch get incr increment prepend replace set)
+
+      def memcache_hit?(result)
+        result.nil? ? 0 : 1
+      end
+
+      def remote_host(key)
+        return unless defined?(Lib.memcached_server_by_key) &&
+                      defined?(@struct) && defined?(is_unix_socket?)
+
+        server_as_array = Lib.memcached_server_by_key(@struct, key.to_s)
+
+        return unless server_as_array.is_a?(Array)
+
+        server = server_as_array.first
+        if is_unix_socket?(server)
+          'localhost'
+        elsif defined?(server.hostname)
+          server.hostname
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/api/metrics.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+module  AppOpticsAPM
+  module API
+    module Metrics
+
+      ##
+      # Internal: method to send duration for a transaction
+      # it checks if it can send metrics with the current transaction name
+      # or a default transaction name and sets the transaction name accordingly
+      #
+      # === Arguments:
+      #
+      # * +span+ the name of the current span (used to construct a transaction name if none is defined)
+      # * +kvs+ A hash containing key/value pairs, only the value of :TransactionName will be relevant
+      #
+      # === Returns:
+      # The result of the block.
+      #
+      # === Assigns:
+      # The transaction_name to kvs[:TransactionName]
+
+      def send_metrics(span, kvs)
+        start = Time.now
+        yield
+      ensure
+        # TODO send_metrics is currently used in grpc, sdk
+        # ____ the error (0,1) would have to be returned from yield
+        error = 0
+        duration = (1000 * 1000 * (Time.now - start)).to_i
+        transaction_name = determine_transaction_name(span, kvs)
+        kvs[:TransactionName] = AppOpticsAPM::Span.createSpan(transaction_name, nil, duration, error)
+        AppOpticsAPM.transaction_name = nil
+      end
+
+      private
+
+      ##
+      # Determine the transaction name to be set on the trace.
+      #
+      # === Argument:
+      # * +span+ the name of the current span (used to construct a transaction name if none is defined)
+      # * +kvs+ (hash, optional) the hash that may have values for 'Controller' and 'Action'
+      #
+      # === Returns:
+      # (string) the determined transaction name
+      #
+      def determine_transaction_name(span, kvs = {})
+        if AppOpticsAPM.transaction_name
+          AppOpticsAPM.transaction_name
+        elsif kvs['Controller'] && kvs['Action']
+          [kvs['Controller'], kvs['Action']].join('.')
+        elsif kvs[:Controller] && kvs[:Action]
+          [kvs[:Controller], kvs[:Action]].join('.')
+        else
+          "custom-#{span}"
+        end
+      end
+
+    end
+  end
+end

data/lib/appoptics_apm/api/tracing.rb

@@ -0,0 +1,57 @@
+#--
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+module AppOpticsAPM
+  module API
+    ##
+    # Provides the higher-level tracing interface for the API
+    #
+    # The tracing methods have been moved to AppOpticsAPM::SDK and AppOpticsAPM::API extends all methods from the SDK
+    # except for start_trace.
+    # AppOpticsAPM::API.start_trace is kept for backwards compatibility because it returns an array
+    # whereas AppOpticsAPM::SDK.start_trace will only return the result of the block.
+    #
+
+    module Tracing
+
+      # Public: Collect metrics and start tracing a given block of code. A
+      # trace will be started depending on configuration and probability.
+      # Detect any exceptions thrown by the block and report errors.
+      #
+      # When start_trace returns control to the calling context, the trace will be
+      # completed and the tracing context will be cleared.
+      #
+      # ==== Arguments
+      #
+      # * +span+   - name for the span to be used as label in the trace view
+      # * +xtrace+ - (optional) incoming X-Trace identifier to be continued
+      # * +opts+   - (optional) hash containing key/value pairs that will be reported along
+      #              with the first event of this span
+      #
+      # ==== Example
+      #
+      #   def handle_request(request, response)
+      #     # ... code that modifies request and response ...
+      #   end
+      #
+      #   def handle_request_with_appoptics(request, response)
+      #     start_trace('custom_span', nil, :TransactionName => 'handle_request') do
+      #       handle_request(request, response)
+      #     end
+      #   end
+      #
+      # Returns an array with the result of the block and the last xtrace used
+      def start_trace(span, xtrace = nil, opts = {})
+        target = {}
+        [start_trace_with_target(span, xtrace, target, opts) { yield }, target['X-Trace']]
+      end
+
+      def profile_method(*args)
+        AppOpticsAPM.logger.warn("DEPRECATED: AppOpticsAPM::API.profile_method is deprecated. Use: AppOpticsAPM::SDK::trace_method")
+        AppOpticsAPM::SDK.trace_method(*args)
+      end
+    end
+  end
+end

data/lib/appoptics_apm/api/util.rb

@@ -0,0 +1,120 @@
+#--
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+require 'pp'
+
+module AppOpticsAPM
+  module API
+    ##
+    # General utility methods for the gem
+    module Util #:nodoc:
+      BACKTRACE_CUTOFF = 200
+
+      # Internal: Check whether the provided key is reserved or not. Reserved
+      # keys are either keys that are handled by liboboe calls or the appoptics_apm gem.
+      #
+      # key - the key to check.
+      #
+      # Return a boolean indicating whether or not key is reserved.
+      def valid_key?(key)
+        ![:Label, :Layer, :Edge, :Timestamp, :Timestamp_u].include?(key.to_sym)
+      end
+
+      # Internal: Get the current backtrace.
+      #
+      # from - int, from position in array of backtraces
+      # to - int, end position in array of backtraces, can be negative to count from the end
+      #
+      # Returns a string with each frame of the backtrace separated by '\r\n'.
+      #
+      def backtrace(from = 0, to = -1)
+        bt = Kernel.caller
+        trim_backtrace(bt[from..to]).join("\r\n")
+      end
+
+      # Internal: Trim a backtrace to a manageable size
+      #
+      # backtrace - the backtrace (an array of stack frames/from Kernel.caller)
+      #
+      # Returns a trimmed backtrace
+      def trim_backtrace(backtrace)
+        return backtrace unless backtrace.is_a?(Array) && backtrace.size > BACKTRACE_CUTOFF
+
+        # Trim backtraces by getting the first 180 and last 20 lines
+        backtrace[0, 180] + ['...[snip]...'] + backtrace[backtrace.size - 20, 20]
+      end
+
+      # Internal: Check if a host is blacklisted from tracing
+      #
+      # addr_port - the addr_port from Net::HTTP although this method
+      # can be used from any component in reality
+      #
+      # Returns a boolean on blacklisted state
+      def blacklisted?(addr_port)
+        return false unless AppOpticsAPM::Config.blacklist
+
+        # Ensure that the blacklist is an array
+        unless AppOpticsAPM::Config.blacklist.is_a?(Array)
+          val = AppOpticsAPM::Config[:blacklist]
+          AppOpticsAPM::Config[:blacklist] = [val.to_s]
+        end
+
+        AppOpticsAPM::Config.blacklist.each do |h|
+          return true if addr_port.to_s.match(h.to_s)
+        end
+
+        false
+      end
+
+      # Internal: Pretty print a list of arguments for reporting
+      #
+      # args - the list of arguments to work on
+      #
+      # Returns a pretty string representation of arguments
+      def pps(*args)
+        old_out = $stdout
+        begin
+          s = StringIO.new
+          $stdout = s
+          pp(*args)
+        ensure
+          $stdout = old_out
+        end
+        s.string
+      end
+
+      # Internal: Determine a string to report representing klass
+      #
+      # args - an instance of a Class, a Class or a Module
+      #
+      # Returns a string representation of klass
+      def get_class_name(klass)
+        kv = {}
+
+        if klass.to_s =~ /::/
+          klass.class.to_s.rpartition('::').last
+        else
+          if klass.is_a?(Class) && klass.is_a?(Module)
+            # Class
+            kv['Class'] = klass.to_s
+
+          elsif !klass.is_a?(Class) && !klass.is_a?(Module)
+            # Class instance
+            kv['Class'] = klass.class.to_s
+
+          else
+            # Module
+            kv['Module'] = klass.to_s
+          end
+        end
+        kv
+      end
+
+      def xtrace_v2?(xtr)
+        xtr && xtr.start_with?('2B')
+      end
+    end
+  end
+end

data/lib/appoptics_apm/api.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+
+  module API
+    extend AppOpticsAPM::API::Logging
+    extend AppOpticsAPM::API::Metrics
+    extend AppOpticsAPM::API::LayerInit
+    extend AppOpticsAPM::API::Util
+
+    require_relative './sdk/tracing'
+    require_relative './sdk/custom_metrics'
+    require_relative './sdk/current_trace'
+    require_relative './sdk/logging' # to make sure it is loaded <- not very elegant
+
+    extend AppOpticsAPM::SDK::Tracing
+    extend AppOpticsAPM::SDK::CustomMetrics
+    extend AppOpticsAPM::API::Tracing
+  end
+end