appoptics_apm 4.1.2 → 4.2.0

data/examples/tracing_background_jobs.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+
+# Make sure oboe is at the bottom of your Gemfile.
+# This is likely redundant but just in case.
+require 'oboe'
+
+# Tracing mode can be 'never' or 'always'
+AppOpticsAPM::Config[:tracing_mode] = 'always'
+
+#
+# Update April 9, 2015 - this is done automagically now
+# and doesn't have to be called manually
+#
+# Load library instrumentation to auto-capture stuff we know about...
+# e.g. ActiveRecord, Cassandra, Dalli, Redis, Memcache, Mongo
+# AppOpticsAPM::Ruby.load
+
+# Some KVs to report to the dashboard
+report_kvs = {}
+report_kvs[:command_line_params] = ARGV.to_s
+report_kvs[:user_id] = `whoami`
+
+AppOpticsAPM::API.start_trace('my_background_job', nil, report_kvs) do
+  #
+  # Initialization code
+  #
+
+  tasks = get_all_tasks
+
+  tasks.each do |t|
+    # Optional: Here we embed another 'trace' to separate actual
+    # work for each task.  In the APPOPTICS dashboard, this will show
+    # up as a large 'my_background_job' parent layer with many
+    # child 'task" layers.
+    AppOpticsAPM::API.trace('task', :task_id => t.id) do
+      t.perform
+    end
+  end
+  #
+  # cleanup code
+  #
+end
+
+# Note that we use 'start_trace' in the outer block and 'trace' for
+# any sub-blocks of code we wish to instrument.  The arguments for
+# both methods vary slightly.
+#
+# TODO update location of the following doc
+# Details in RubyDoc:
+# https://www.omniref.com/ruby/gems/oboe/2.7.10.1/symbols/AppOpticsAPM::API::Tracing#tab=Methods

data/examples/tracing_forked_processes.rb

@@ -0,0 +1,99 @@
+#
+# This sample demonstrates how to instrument a main loop that
+# retrieves work and calls fork to do the actual work
+#
+
+require 'math'
+require 'oboe'
+
+AppOpticsAPM::Config[:tracing_mode] = :always
+AppOpticsAPM::Config[:verbose] = true
+
+# The parent process/loop which collects data
+Kernel.loop do
+  # For each loop, we instrument the work retrieval.  These traces
+  # will show up as layer 'get_the_work'.
+  AppOpticsAPM::API.start_trace('get_the_work') do
+    work = get_the_work
+
+    # Loop through work and pass to `do_the_work` method
+    # that spawns a thread each time
+    work.each do |job|
+      fork do
+        # Since the context is copied from the parent process, we clear it
+        # and start a new trace via `AppOpticsAPM::API.start_trace`.
+        AppOpticsAPM::Context.clear
+        result = nil
+
+        AppOpticsAPM::API.start_trace('do_the_work', nil, :job_id => job.id) do
+          result = do_the_work(job)
+        end
+
+        result
+      end
+    end
+  end
+end
+
+##
+# get_the_work
+#
+# Method to retrieve work to do
+#
+def get_the_work
+  # We'll just return random integers as a
+  # fake work load
+  w = []
+  w << rand(25)
+  w << rand(25)
+  w << rand(25)
+end
+
+##
+# do_the_work
+#
+# The work-horse method
+#
+def do_the_work(job_to_do)
+  i = job_to_do
+  i * Math::PI
+end
+
+#########################################################################
+# Notes
+#########################################################################
+
+# If your parent process only forks a small number of processes per loop (< 5..10),
+# you may want to mark the child traces as asynchronous and have them directly
+# linked to the parent tracing context.
+#
+# The benefit of this is that instead of having two independent traces (parent
+# and child), you will have a single view of the parent trace showing the
+# spawned child process and it's performance in the AppOptics dashboard.
+#
+# To do this:
+#   1. Don't clear the context in the child process
+#   2. Use `AppOpticsAPM::API.trace` instead
+#   3. Pass the `Async` flag to mark this child as asynchronous
+#
+Kernel.loop do
+  AppOpticsAPM::API.start_trace('get_the_work') do
+
+    work = get_the_work
+
+    work.each do |job|
+      fork do
+        result = nil
+        # 1 Don't clear context
+        # 2 Use `AppOpticsAPM::API.trace` instead
+        # 3 Pass the Async flag
+        AppOpticsAPM::API.trace('do_the_work', {:job_id => job.id, :Async => 1 }) do
+          result = do_the_work(job)
+        end
+
+        result
+      end
+    end
+  end
+  sleep 5
+end

data/examples/unicorn_on_heroku_config.rb

@@ -0,0 +1,28 @@
+worker_processes Integer(ENV["WEB_CONCURRENCY"] || 3)
+timeout 15
+preload_app true
+
+before_fork do |server, worker|
+  Signal.trap 'TERM' do
+    puts 'Unicorn master intercepting TERM and sending myself QUIT instead'
+    Process.kill 'QUIT', Process.pid
+  end
+
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+
+  defined?(::AppOpticsAPM) and
+    ::AppOpticsAPM.disconnect!
+end
+
+after_fork do |server, worker|
+  Signal.trap 'TERM' do
+    puts 'Unicorn worker intercepting TERM and doing nothing. Wait for master to send QUIT'
+  end
+
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+
+  defined?(::AppOpticsAPM) and
+    ::AppOpticsAPM.reconnect!
+end

data/ext/oboe_metal/src/VERSION

@@ -1 +1 @@
-2.0.10
+3.0.0

data/lib/appoptics_apm.rb

@@ -60,6 +60,8 @@ begin
     require 'appoptics_apm/frameworks/sinatra'
     require 'appoptics_apm/frameworks/padrino'
     require 'appoptics_apm/frameworks/grape'
+  else
+    require 'appoptics_apm/noop/context'
   end
 
   # Load Ruby module last.  If there is no framework detected,

data/lib/appoptics_apm/api/logging.rb

@@ -40,7 +40,7 @@ module AppOpticsAPM
       #
       # Returns nothing.
       def log(layer, label, opts = {}, event=nil)
-        return if !AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
         event ||= AppOpticsAPM::Context.createEvent
         log_event(layer, label, event, opts)
@@ -66,11 +66,11 @@ module AppOpticsAPM
       #
       # Returns nothing.
       def log_exception(layer, exn, opts = {})
-        return if !AppOpticsAPM.tracing? || exn.instance_variable_get(:@oboe_logged)
+        return AppOpticsAPM::Context.toString if !AppOpticsAPM.tracing? || exn.instance_variable_get(:@oboe_logged)
 
         unless exn
           AppOpticsAPM.logger.debug '[appoptics_apm/debug] log_exception called with nil exception'
-          return
+          return AppOpticsAPM::Context.toString
         end
 
         opts.merge!(:ErrorClass => exn.class.name,
@@ -180,12 +180,11 @@ module AppOpticsAPM
       #
       # Returns an xtrace metadata string if we are tracing
       def log_end(layer, opts = {})
-        return unless AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
-        log_event(layer, :exit, AppOpticsAPM::Context.createEvent, opts) if AppOpticsAPM.tracing?
-        AppOpticsAPM::Context.toString
+        log_event(layer, :exit, AppOpticsAPM::Context.createEvent, opts)
       ensure
-        # FIXME has_incoming_context commented out, it has importance for JRuby only and breaks ruby tests
+        # FIXME has_incoming_context commented out, it has importance for JRuby only but breaks Ruby tests
         AppOpticsAPM::Context.clear # unless AppOpticsAPM.has_incoming_context?
       end
 
@@ -206,7 +205,7 @@ module AppOpticsAPM
       #
       # Returns an xtrace metadata string if we are tracing
       def log_entry(layer, opts = {}, op = nil)
-        return unless AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
         AppOpticsAPM.layer_op = op.to_sym if op
         log_event(layer, :entry, AppOpticsAPM::Context.createEvent, opts)
@@ -228,7 +227,7 @@ module AppOpticsAPM
       #
       # Returns an xtrace metadata string if we are tracing
       def log_info(layer, opts = {})
-        return unless AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
         log_event(layer, :info, AppOpticsAPM::Context.createEvent, opts)
       end
@@ -251,7 +250,7 @@ module AppOpticsAPM
       #
       # Returns an xtrace metadata string  if we are tracing
       def log_exit(layer, opts = {}, op = nil)
-        return unless AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
         AppOpticsAPM.layer_op = nil if op
         log_event(layer, :exit, AppOpticsAPM::Context.createEvent, opts)
@@ -270,7 +269,7 @@ module AppOpticsAPM
       # * +traces+ - An array with X-Trace strings returned from the requests
       #
       def log_multi_exit(layer, traces)
-        return unless AppOpticsAPM.tracing?
+        return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
         task_id = AppOpticsAPM::XTrace.task_id(AppOpticsAPM::Context.toString)
         event = AppOpticsAPM::Context.createEvent
         traces.each do |trace|
@@ -289,7 +288,7 @@ module AppOpticsAPM
       # * +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 unless context.isValid
+        return AppOpticsAPM::Context.toString unless context.isValid
 
         event = context.createEvent
         event.addInfo(APPOPTICS_STR_LAYER, layer.to_s)
@@ -299,6 +298,7 @@ module AppOpticsAPM
         end
 
         AppOpticsAPM::Reporter.sendStatus(event, context)
+        AppOpticsAPM::Context.toString
       end
 
       private
@@ -353,6 +353,7 @@ module AppOpticsAPM
         end if !opts.nil? && opts.any?
 
         AppOpticsAPM::Reporter.sendReport(event)
+        AppOpticsAPM::Context.toString
       end
 
     end

data/lib/appoptics_apm/api/tracing.rb

@@ -51,7 +51,8 @@ module AppOpticsAPM
       #
       # Returns the result of the block.
       def trace(layer, opts = {}, protect_op = nil)
-        return if protect_op && AppOpticsAPM.layer_op == protect_op.to_sym
+        return if !AppOpticsAPM.loaded || (protect_op && AppOpticsAPM.layer_op == protect_op.to_sym)
+
         log_entry(layer, opts, protect_op)
         begin
           yield
@@ -158,6 +159,32 @@ module AppOpticsAPM
           AppOpticsAPM::Context.clear
         end
       end
+
+      # 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
+      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/base.rb

@@ -42,6 +42,12 @@ module AppOpticsAPMBase
   thread_local :sample_rate
   thread_local :layer
   thread_local :layer_op
+
+  # transaction_name is used for custom transaction naming
+  # It needs to be globally accessible, but is only set by the request processors of the different frameworks
+  # and read by rack
+  thread_local :transaction_name
+
   # Semaphore used during the test suite to test
   # global config options.
   thread_local :config_lock
@@ -54,7 +60,7 @@ module AppOpticsAPMBase
   # X-Trace request header, tracing may have already been started
   # by Joboe.  Such a scenario occurs when the application is being
   # hosted by a Java container (such as Tomcat or Glassfish) and
-  # JAppOpticsAPM has already initiated tracing.  In this case, we shouldn't
+  # AppOpticsAPM has already initiated tracing.  In this case, we shouldn't
   # pickup the X-Trace context in the X-Trace header and we shouldn't
   # set the outgoing response X-Trace header or clear context.
   # Yeah I know.  Yuck.

data/lib/appoptics_apm/config.rb

@@ -73,31 +73,32 @@ module AppOpticsAPM
     # to create an output similar to the content of the config file
     #
     def self.print_config
-      puts "# General configurations"
+      AppOpticsAPM.logger.warn "# General configurations"
       non_instrumentation = @@config.keys - @@instrumentation
       non_instrumentation.each do |config|
-        puts "AppOpticsAPM::Config[:#{config}] = #{@@config[config]}"
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}] = #{@@config[config]}"
       end
 
-      puts "\n# Instrumentation specific configurations"
-      puts "# Enabled/Disabled Instrumentation"
+      AppOpticsAPM.logger.warn "\n# Instrumentation specific configurations"
+      AppOpticsAPM.logger.warn "# Enabled/Disabled Instrumentation"
       @@instrumentation.each do |config|
-        puts "AppOpticsAPM::Config[:#{config}][:enabled] = #{@@config[config][:enabled]}"
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:enabled] = #{@@config[config][:enabled]}"
       end
 
-      puts "\n# Enabled/Disabled Backtrace Collection"
+      AppOpticsAPM.logger.warn "\n# Enabled/Disabled Backtrace Collection"
       @@instrumentation.each do |config|
-        puts "AppOpticsAPM::Config[:#{config}][:collect_backtraces] = #{@@config[config][:collect_backtraces]}"
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:collect_backtraces] = #{@@config[config][:collect_backtraces]}"
+        AppOpticsAPM.logger.warn
       end
 
-      puts "\n# Logging of outgoing HTTP query args"
+      AppOpticsAPM.logger.warn "\n# Logging of outgoing HTTP query args"
       @@instrumentation.each do |config|
-        puts "AppOpticsAPM::Config[:#{config}][:log_args] = #{@@config[config][:log_args]}"
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:log_args] = #{@@config[config][:log_args]}"
       end
 
-      puts "\n# Bunny Controller and Action"
-      puts "AppOpticsAPM::Config[:bunnyconsumer][:controller] = #{@@config[:bunnyconsumer][:controller].inspect}"
-      puts "AppOpticsAPM::Config[:bunnyconsumer][:action] = #{@@config[:bunnyconsumer][:action].inspect}"
+      AppOpticsAPM.logger.warn "\n# Bunny Controller and Action"
+      AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:bunnyconsumer][:controller] = #{@@config[:bunnyconsumer][:controller].inspect}"
+      AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:bunnyconsumer][:action] = #{@@config[:bunnyconsumer][:action].inspect}"
       nil
     end
 
@@ -112,7 +113,8 @@ module AppOpticsAPM
       @@instrumentation.each do |k|
         @@config[k] = {}
       end
-     load(File.join(File.dirname(File.dirname(__FILE__)),
+      @@config[:transaction_name] = {}
+      load(File.join(File.dirname(File.dirname(__FILE__)),
                     'rails/generators/appoptics_apm/templates/appoptics_apm_initializer.rb'))
     end
     # rubocop:enable Metrics/AbcSize

data/lib/appoptics_apm/frameworks/grape.rb

@@ -51,6 +51,8 @@ module AppOpticsAPM
         def error_response_with_appoptics(error = {})
           status, headers, body = error_response_without_appoptics(error)
 
+          xtrace = AppOpticsAPM::Context.toString
+
           if AppOpticsAPM.tracing?
             # Since Grape uses throw/catch and not Exceptions, we manually log
             # the error here.
@@ -58,18 +60,17 @@ module AppOpticsAPM
             kvs[:ErrorClass] = 'GrapeError'
             kvs[:ErrorMsg] = error[:message] ? error[:message] : "No message given."
             kvs[:Backtrace] = ::AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
-
-            ::AppOpticsAPM::API.log(nil, 'error', kvs)
+            ::AppOpticsAPM::API.log('rack', 'error', kvs)
 
             # Since calls to error() are handled similar to abort in Grape.  We
             # manually log the rack exit here since the original code won't
             # be returned to
             xtrace = AppOpticsAPM::API.log_end('rack', :Status => status)
+          end
 
-            if headers && AppOpticsAPM::XTrace.valid?(xtrace)
-              unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
-                headers['X-Trace'] = xtrace if headers.is_a?(Hash)
-              end
+          if headers && AppOpticsAPM::XTrace.valid?(xtrace)
+            unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
+              headers['X-Trace'] = xtrace if headers.is_a?(Hash)
             end
           end