appoptics_apm 4.2.2 → 4.2.3

data/ext/oboe_metal/src/VERSION

@@ -1 +1 @@
-3.0.1
+3.0.2

data/lib/appoptics_apm/api.rb

@@ -2,16 +2,17 @@
 # All rights reserved.
 
 module AppOpticsAPM
-  ##
-  # This module implements the AppOpticsAPM tracing API.
-  # See: https://docs.appoptics.com/kb/apm_tracing/ruby/sdk/
+
   module API
-    def self.extend_with_tracing
-      extend AppOpticsAPM::API::Logging
-      extend AppOpticsAPM::API::Tracing
-      extend AppOpticsAPM::API::Profiling
-      extend AppOpticsAPM::API::LayerInit
-    end
+    extend AppOpticsAPM::API::Logging
+    extend AppOpticsAPM::API::Metrics
+    extend AppOpticsAPM::API::Profiling
+    extend AppOpticsAPM::API::LayerInit
     extend AppOpticsAPM::API::Util
+
+    require_relative './sdk'
+
+    extend AppOpticsAPM::SDK::Tracing
+    extend AppOpticsAPM::API::Tracing
   end
 end

data/lib/appoptics_apm/api/layerinit.rb

@@ -27,7 +27,7 @@ module AppOpticsAPM
       # force_trace has been deprecated and will be removed in a subsequent version.
       #
       def force_trace
-        AppOpticsAPM.logger.warn 'AppOpticsAPM::API::LayerInit.force_trace has been deprecated and will be ' \
+        AppOpticsAPM.logger.warn '[appoptics_apm/api] AppOpticsAPM::API::LayerInit.force_trace has been deprecated and will be ' \
                          'removed in a subsequent version.'
 
         saved_mode = AppOpticsAPM::Config[:tracing_mode]

data/lib/appoptics_apm/api/logging.rb

@@ -16,7 +16,7 @@ module AppOpticsAPM
     ##
     # This modules provides the X-Trace logging facilities.
     #
-    # These are the lower level methods, please see AppOpticsAPM::API::Tracing
+    # These are the lower level methods, please see AppOpticsAPM::SDK
     # for the higher level methods
     module Logging
       @@ints_or_nil = [Integer, Float, NilClass, String]
@@ -52,7 +52,7 @@ module AppOpticsAPM
       # ==== Arguments
       #
       # * +layer+ - The layer the reported event belongs to
-      # * +exn+ - The exception to report
+      # * +exception+ - The exception to report
       # * +opts+ - Custom params if you want to log extra information
       #
       # ==== Example
@@ -65,19 +65,19 @@ module AppOpticsAPM
       #   end
       #
       # Returns nothing.
-      def log_exception(layer, exn, opts = {})
-        return AppOpticsAPM::Context.toString if !AppOpticsAPM.tracing? || exn.instance_variable_get(:@oboe_logged)
+      def log_exception(layer, exception, opts = {})
+        return AppOpticsAPM::Context.toString if !AppOpticsAPM.tracing? || exception.instance_variable_get(:@exn_logged)
 
-        unless exn
+        unless exception
           AppOpticsAPM.logger.debug '[appoptics_apm/debug] log_exception called with nil exception'
           return AppOpticsAPM::Context.toString
         end
 
-        opts.merge!(:ErrorClass => exn.class.name,
-                    :ErrorMsg => exn.message,
-                    :Backtrace => exn.backtrace.join("\r\n")) if exn.backtrace
+        opts.merge!(:ErrorClass => exception.class.name,
+                    :ErrorMsg => exception.message,
+                    :Backtrace => exception.backtrace.join("\r\n")) if exception.backtrace
 
-        exn.instance_variable_set(:@oboe_logged, true)
+        exception.instance_variable_set(:@exn_logged, true)
         log(layer, :error, opts)
       end
 
@@ -125,7 +125,7 @@ module AppOpticsAPM
         # end
         #++
 
-        if AppOpticsAPM.sample?(opts.merge(:layer => layer, :xtrace => xtrace))
+        if AppOpticsAPM.sample?(opts.merge(:xtrace => xtrace))
           # Yes, we're sampling this request
           # Probablistic tracing of a subset of requests based off of
           # sample rate and sample source
@@ -179,13 +179,18 @@ module AppOpticsAPM
       #   AppOpticsAPM::API.log_end(:layer_name, { :id => @user.id })
       #
       # Returns an xtrace metadata string if we are tracing
-      def log_end(layer, opts = {})
+      def log_end(layer, opts = {}, event = nil)
         return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
-        log_event(layer, :exit, AppOpticsAPM::Context.createEvent, opts)
+        # Deal with the transaction name
+        opts[:TransactionName] = determine_transaction_name(layer, opts)
+
+        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
 
       ##
@@ -301,6 +306,25 @@ module AppOpticsAPM
         AppOpticsAPM::Context.toString
       end
 
+      ##
+      # Determine the transaction name to be set on the trace
+      #
+      # A transaction name set via the opts key `:TransactionName` takes precedence
+      # over a currently set custom transaction name. if neither are provided it
+      # returns `"custom_#{span}"`
+      #
+      # === Argument:
+      # * +opts+ (hash) the value of :TransactionName will be set as custom transaction name
+      #
+      # === Returns:
+      # (string) the current transaction name
+      #
+      def determine_transaction_name(span, opts = {})
+        opts[:TransactionName] ||= opts.delete('TransactionName')
+        AppOpticsAPM::API.set_transaction_name(opts[:TransactionName])
+        AppOpticsAPM.transaction_name || "custom-#{span}"
+      end
+
       private
 
       ##
@@ -347,8 +371,8 @@ module AppOpticsAPM
           begin
             event.addInfo(k.to_s, value)
           rescue ArgumentError => e
-            AppOpticsAPM.logger.debug "[AppOpticsAPM/debug] Couldn't add event KV: #{k} => #{v.class}"
-            AppOpticsAPM.logger.debug "[AppOpticsAPM/debug] #{e.message}"
+            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?
 
@@ -356,6 +380,9 @@ module AppOpticsAPM
         AppOpticsAPM::Context.toString
       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/metrics.rb

@@ -0,0 +1,34 @@
+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.
+      #
+
+      def send_metrics(span, kvs = {})
+        # This is a new span, we do not know the transaction name yet
+        AppOpticsAPM.transaction_name = nil
+
+        # if a transaction name is provided it will take precedence over transaction names defined
+        # later or in lower spans
+        start = Time.now
+
+        yield
+      ensure
+        duration =(1000 * 1000 * (Time.now - start)).round(0)
+        transaction_name = AppOpticsAPM::API.determine_transaction_name(span, kvs)
+        kvs[:TransactionName] = AppOpticsAPM::API.set_transaction_name(AppOpticsAPM::Span.createSpan(transaction_name, nil, duration))
+      end
+    end
+  end
+end

data/lib/appoptics_apm/api/profiling.rb

@@ -198,6 +198,11 @@ module AppOpticsAPM
         # Merge in any extra_kvs requested
         report_kvs.merge!(extra_kvs)
       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/tracing.rb

@@ -6,77 +6,29 @@
 module AppOpticsAPM
   module API
     ##
-    # Provides the higher-level tracing interface for the API.
+    # Provides the higher-level tracing interface for the API
     #
-    # Traces are best created with a <tt>AppOpticsAPM:API.start_trace</tt> block and
-    # <tt>AppOpticsAPM:API.trace</tt> blocks around calls to be traced.
-    # These two methods guarantee proper nesting of tracing and handling of the tracing context.
+    # 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.
     #
-    # Some optional keys that can be used in the +opts+ hash:
-    # * +:TransactionName+ - this will show up in the transactions column in the traces dashboard
-    # * +:Controller+ - if present will be combined with +Action+ and show up as transaction in the traces dashboard
-    # * +:Action+ - if present will be combined with +Controller+ and show up as transaction in the traces dashboard
-    # * +:HTTP-Host+ - domain portion of URL
-    # * +:URL+ - request URI
-    # * +:Method+
-    #
-    # TODO complete the above
-    #
-    # Invalid keys: +:Label+, +:Layer+, +:Edge+, +:Timestamp+, +:Timestamp_u+
-    #
-    module Tracing
-      # Public: Trace a given block of code. Detect any exceptions thrown by
-      # the block and report errors.
-      #
-      # * +:layer+ - The layer the block of code belongs to.
-      # * +:opts+ - A hash containing key/value pairs that will be reported along
-      #   with the first event of this layer (optional).
-      # * +:protect_op+ - The operation being traced.  Used to avoid
-      #   double tracing operations that call each other
-      #
-      # Example
-      #
-      #   def computation(n)
-      #     fib(n)
-      #     raise Exception.new
-      #   end
-      #
-      #   def computation_with_oboe(n)
-      #     trace('fib', { :number => n }, :fib) do
-      #       computation(n)
-      #     end
-      #   end
-      #
-      #   result = computation_with_oboe(1000)
-      #
-      # Returns the result of the block.
-      def trace(layer, opts = {}, protect_op = nil)
-        return if !AppOpticsAPM.loaded || (protect_op && AppOpticsAPM.layer_op == protect_op.to_sym)
 
-        log_entry(layer, opts, protect_op)
-        begin
-          yield
-        rescue Exception => e
-          log_exception(layer, e)
-          raise
-        ensure
-          log_exit(layer, opts, protect_op)
-        end
-      end
+    module Tracing
 
-      # Public: Trace a given block of code which can start a trace depending
-      # on configuration and probability. Detect any exceptions thrown by the
-      # block and report errors.
+      # 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 oboe
-      # context will be cleared.
+      # When start_trace returns control to the calling context, the trace will be
+      # completed and the tracing context will be cleared.
       #
       # ==== Arguments
       #
-      # * +layer+  - name for the layer to be used as label in the trace view
+      # * +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 layer (optional)
+      #              with the first event of this span
       #
       # ==== Example
       #
@@ -85,106 +37,39 @@ module AppOpticsAPM
       #   end
       #
       #   def handle_request_with_appoptics(request, response)
-      #     result, xtrace = start_trace('rails', request['X-Trace']) do
+      #     start_trace('custom_span', nil, :TransactionName => 'handle_request') do
       #       handle_request(request, response)
       #     end
-      #     result
-      #   rescue Exception => e
-      #     xtrace = e.xtrace
-      #   ensure
-      #     response['X-trace'] = xtrace
       #   end
       #
-      # Returns a list of length two, the first element of which is the result
-      # of the block, and the second element of which is the oboe context that
-      # was set when the block completed execution.
-      def start_trace(layer, xtrace = nil, opts = {})
+      # Returns an array with the result of the block and the last xtrace used
+      def start_trace(span, xtrace = nil, opts = {})
         return [yield, nil] unless AppOpticsAPM.loaded
 
-        log_start(layer, xtrace, opts)
-        begin
-          result = yield
-        rescue Exception => e
-          log_exception(layer, e)
-          e.instance_variable_set(:@xtrace, log_end(layer))
-          raise
-        end
-        xtrace = log_end(layer)
-
-        [result, xtrace]
-      end
+        # if it is not an entry span!
+        return [trace(span, opts) { yield }, AppopticsAPM::Context.toString] if AppOpticsAPM::Context.isValid
 
-      # Public: Trace a given block of code which can start a trace depending
-      # on configuration and probability. Detect any exceptions thrown by the
-      # block and report errors. Assign an X-Trace to the target.
-      #
-      # The motivating use case for this is HTTP streaming in rails3. We need
-      # access to the exit event's trace id so we can set the header before any
-      # work is done, and before any headers are sent back to the client.
-      #
-      # ===== Arguments
-      # * +layer+ - The layer the block of code belongs to.
-      # * +xtrace+ - string - The X-Trace to continue by the target
-      # * +target+ - has to respond to #[]=, The target object in which to place the trace information
-      # * +opts+ - A hash containing key/value pairs that will be reported along
-      #   with the first event of this layer (optional).
-      #
-      # ==== Example
-      #
-      #   def handle_request(request, response)
-      #     # ... code that does something with request and response ...
-      #   end
-      #
-      #   def handle_request_with_appoptics(request, response)
-      #     start_trace_with_target('rails', request['X-Trace'], response) do
-      #       handle_request(request, response)
-      #     end
-      #   end
-      #
-      # Returns the result of the block.
-      def start_trace_with_target(layer, xtrace, target, opts = {})
-        return yield unless AppOpticsAPM.loaded
+        log_start(span, xtrace, opts)
 
-        log_start(layer, xtrace, opts)
-        exit_evt = AppOpticsAPM::Context.createEvent
-        begin
-          target['X-Trace'] = AppOpticsAPM::EventUtil.metadataString(exit_evt) if AppOpticsAPM.tracing?
-          yield
-        rescue Exception => e
-          log_exception(layer, e)
-          raise
-        ensure
-          exit_evt.addEdge(AppOpticsAPM::Context.get)
-          log(layer, :exit, {}, exit_evt)
-          AppOpticsAPM::Context.clear
+        # send_metrics deals with the logic for setting AppOpticsAPM.transaction_name
+        # and ensures that metrics are sent
+        # log_end sets the transaction_name
+        result = send_metrics(span, opts) do
+          begin
+            yield
+          rescue Exception => e # rescue everything ok, since we are raising
+            AppOpticsAPM::API.log_exception(span, e)
+            e.instance_variable_set(:@xtrace, log_end(span))
+            raise
+          end
         end
-      end
+        xtrace = AppopticsAPM::Context.toString
+        log_end(span, opts)
 
-      # Public: Set a ThreadLocal custom transaction name to be used when sending a trace or metrics for the
-      # current transaction
-      #
-      # In addition to setting a transaction name here there is also a configuration
-      # AppOpticsAPM::Config['transaction_name']['prepend_domain'] which allows to have the domain prepended
-      # to the transaction name
-      #
-      # ===== Arguments
-      # * +name+ - A non-empty string with the custom transaction name
-      #
-      def set_transaction_name(name)
-        if name.is_a?(String) && name.strip != ''
-          AppOpticsAPM.transaction_name = name
-        else
-          AppOpticsAPM.logger.debug "[appoptics_apm/api] Could not set transaction name, provided name is empty or not a String."
-        end
-        AppOpticsAPM.transaction_name
+        [result, xtrace]
       end
 
 
-      # this is provided for testing
-      # returns the current transaction name
-      def get_transaction_name
-        AppOpticsAPM.transaction_name
-      end
     end
   end
 end

data/lib/appoptics_apm/api/util.rb

@@ -42,16 +42,10 @@ module AppOpticsAPM
       #
       # Returns a trimmed backtrace
       def trim_backtrace(backtrace)
-        return backtrace unless backtrace.is_a?(Array)
+        return backtrace unless backtrace.is_a?(Array) && backtrace.size > BACKTRACE_CUTOFF
 
-        length = backtrace.size
-        if length > BACKTRACE_CUTOFF
-          # Trim backtraces by getting the first 180 and last 20 lines
-          trimmed = backtrace[0, 180] + ['...[snip]...'] + backtrace[length - 20, 20]
-        else
-          trimmed = backtrace
-        end
-        trimmed
+        # Trim backtraces by getting the first 180 and last 20 lines
+        backtrace[0, 180] + ['...[snip]...'] + backtrace[length - 20, 20]
       end
 
       # Internal: Check if a host is blacklisted from tracing

data/lib/appoptics_apm/base.rb

@@ -2,25 +2,24 @@
 # All rights reserved.
 
 # Constants from liboboe
-OBOE_TRACE_NEVER   = 0
-OBOE_TRACE_ALWAYS  = 1
-OBOE_TRACE_THROUGH = 2
+APPOPTICS_TRACE_NEVER   = 0
+APPOPTICS_TRACE_ALWAYS  = 1
 
-OBOE_SAMPLE_RATE_SOURCE_FILE                   = 1
-OBOE_SAMPLE_RATE_SOURCE_DEFAULT                = 2
-OBOE_SAMPLE_RATE_SOURCE_OBOE                   = 3
-OBOE_SAMPLE_RATE_SOURCE_LAST_OBOE              = 4
-OBOE_SAMPLE_RATE_SOURCE_DEFAULT_MISCONFIGURED  = 5
-OBOE_SAMPLE_RATE_SOURCE_OBOE_DEFAULT           = 6
+# OBOE_SAMPLE_RATE_SOURCE_FILE                   = 1
+# OBOE_SAMPLE_RATE_SOURCE_DEFAULT                = 2
+# OBOE_SAMPLE_RATE_SOURCE_OBOE                   = 3
+# OBOE_SAMPLE_RATE_SOURCE_LAST_OBOE              = 4
+# OBOE_SAMPLE_RATE_SOURCE_DEFAULT_MISCONFIGURED  = 5
+# OBOE_SAMPLE_RATE_SOURCE_OBOE_DEFAULT           = 6
 
 # Masks for bitwise ops
-ZERO_MASK = 0b0000000000000000000000000000
+# ZERO_MASK = 0b0000000000000000000000000000
 
 SAMPLE_RATE_MASK   = 0b0000111111111111111111111111
 SAMPLE_SOURCE_MASK = 0b1111000000000000000000000000
 
-ZERO_SAMPLE_RATE_MASK   = 0b1111000000000000000000000000
-ZERO_SAMPLE_SOURCE_MASK = 0b0000111111111111111111111111
+# ZERO_SAMPLE_RATE_MASK   = 0b1111000000000000000000000000
+# ZERO_SAMPLE_SOURCE_MASK = 0b0000111111111111111111111111
 
 APPOPTICS_STR_BLANK = ''.freeze
 APPOPTICS_STR_LAYER = 'Layer'.freeze