appoptics_apm 4.1.1 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bec85d45871f627c9a17c7d4ee6e592d33b1df21
-  data.tar.gz: c3bfd02109828928249837b492672ec0f7f5a0e8
+  metadata.gz: 279e04ea7b50365f82a752e34561e98553accfbf
+  data.tar.gz: 6c164062efc035368cec63f422689ae0317b8986
 SHA512:
-  metadata.gz: 847a79988f646a46381ee1ca6d581e500a8aa5e156569143aee9e846ef63b2dd0ec7a9686d8dce16e6f843185d758e1a87f88fe07d003546be2147a90f6d6bab
-  data.tar.gz: 5969da7af7a351e23d569ca2e02338164029227a97d73885ab0e0d042ae3f029c8b18d2f5d4c20c4089fe7881c2092756f08069272237eed6be54acb6443a5f1
+  metadata.gz: 58716fc2e035939241428b70b45ce5e090238c71758d72fa9b29e2fbdc11fd34f89e97d5a44d6f769d8a3edf80f6ce4e02aaea6e3b1a4b001778970cf43a81ca
+  data.tar.gz: aacc0674ebe52dda370cec24c6a194a4e57bc0e41dddbae3e9e93b0565350f96d42a41119fe895e4148741bfe7262a7396e1c513242a2e6f4d6303f2f3d0022f

data/Dockerfile_test

@@ -1,5 +1,8 @@
 FROM ubuntu:16.04
 
+# to use with ./run_tests_docker.rb
+# docker build -f Dockerfile-test -t ruby_appoptics_apm .
+
 # install OS packages
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \
@@ -36,7 +39,7 @@ RUN . ~/.profile \
     && rbenv install 2.3.6 \
     && rbenv install 2.4.3 \
     && rbenv install 2.5.0
-#    && rbenv install jruby-9.0.5.0
+    && rbenv install jruby-9.1.16.0
 
 # install swig 3.0.8
 RUN curl -SL http://kent.dl.sourceforge.net/project/swig/swig/swig-3.0.8/swig-3.0.8.tar.gz \

data/appoptics_apm.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.description = %q{The AppOpticsAPM gem provides performance instrumentation for MRI Ruby and related frameworks.}
 
   s.extra_rdoc_files = ["LICENSE"]
-  s.files = `git ls-files`.split("\n").reject { |f| f.match(%r{^(test|gemfiles)/}) }
+  s.files = `git ls-files`.split("\n").reject { |f| f.match(%r{^(test|gemfiles|examples)/}) }
   s.files += ['ext/oboe_metal/src/oboe.h',
               'ext/oboe_metal/src/oboe.hpp',
               'ext/oboe_metal/src/oboe_debug.h',

data/lib/appoptics_apm/frameworks/rails/inst/action_controller_api.rb

@@ -18,7 +18,7 @@ module AppOpticsAPM
             :Action       => self.action_name
         }
         request.env['appoptics_apm.controller'] = kvs[:Controller]
-        request.env['appoptics_apm.action'] = kvs[:Controller]
+        request.env['appoptics_apm.action'] = kvs[:Action]
 
         return super(method_name, *args) unless AppOpticsAPM.tracing?
         begin

data/lib/appoptics_apm/frameworks/rails/inst/active_record.rb

@@ -7,7 +7,7 @@ require 'appoptics_apm/frameworks/rails/inst/connection_adapters/postgresql'
 
 if AppOpticsAPM::Config[:active_record][:enabled] && !defined?(JRUBY_VERSION)
   begin
-    adapter = ActiveRecord::Base.connection.adapter_name.downcase
+    adapter = ActiveRecord::Base.configurations[Rails.env]['adapter']
 
     if Rails::VERSION::MAJOR < 5
       require 'appoptics_apm/frameworks/rails/inst/connection_adapters/utils'

data/lib/appoptics_apm/version.rb

@@ -8,7 +8,7 @@ module AppOpticsAPM
   module Version
     MAJOR = 4
     MINOR = 1
-    PATCH = 1
+    PATCH = 2
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/ruby_setup.sh

@@ -3,7 +3,7 @@
 # used by run_tests_docker.sh
 # call with:
 # docker-compose run --service-ports ruby_appoptics_apm /code/ruby-appoptics_apm/ruby_setup.sh <ruby-version> <gemfile> <DBNAME=mysql2> <true|false>
-# docker-compose run --service-ports ruby_appoptics_apm /code/ruby-appoptics_apm/ruby_setup.sh 2.4.1 gemfiles/libraries.gemfile
+# docker-compose run --service-ports ruby_appoptics_apm /code/ruby-appoptics_apm/ruby_setup.sh 2.4.3 gemfiles/libraries.gemfile
 
 cd /code/ruby-appoptics_apm/
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appoptics_apm
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.1.2
 platform: ruby
 authors:
 - Maia Engeli
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-03 00:00:00.000000000 Z
+date: 2018-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -133,14 +133,6 @@ files:
 - build_gems.sh
 - config/initializers/.keep
 - docker-compose.yml
-- examples/DNT.md
-- examples/carrying_context.rb
-- examples/instrumenting_metal_controller.rb
-- examples/puma_on_heroku_config.rb
-- examples/tracing_async_threads.rb
-- examples/tracing_background_jobs.rb
-- examples/tracing_forked_processes.rb
-- examples/unicorn_on_heroku_config.rb
 - ext/oboe_metal/extconf.rb
 - ext/oboe_metal/lib/.keep
 - ext/oboe_metal/noop/noop.c

data/examples/DNT.md

@@ -1,35 +0,0 @@
-By default, the AppOpticsAPM gem will not trace routes with extensions
-for common static files.  Examples of such files may be images,
-javascript, pdfs and text files.
-
-This is done by using the regular expression stored in
-`AppOpticsAPM::Config[:dnt_regexp]`:
-
-    .(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|ttf|woff|svg|less)$
-
-This string is used as a regular expression and is tested against
-candidate URLs to be instrumented.
-
-To replace the pattern in use, you can update this regular expression
-string.  Here are some examples.
-
-If you prefer that you want your javascript and CSS files instrumented,
-you can update `AppOpticsAPM::Config[:dnt_regexp]` with an updated regexp
-pattern (without the "js" and "css" entries):
-
-    .(jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|flv|swf|ttf|woff|svg|less)$
-
-If you prefer to not instrument all javascript files except for one
-named `show.js`, you could put this assignment into your initializer,
-rackup file or application.rb (note that this example uses a standard
-regexp [negative
-look-behind](http://www.regular-expressions.info/lookaround.html) that
-isn't supported in Ruby 1.8):
-
-    AppOpticsAPM::Config[:dnt_regexp] = "(\.js$)(?<!show.js)"
-
-Since this pattern is used with the standard Ruby Regexp class, you can
-use any Regexp supported pattern.  See the documentation on Ruby Regexp
-[here](https://www.omniref.com/ruby/2.2.0/symbols/Regexp?d=380181456&n=0#doc_uncollapsed=true&d=380181456&n=0)
-or you can also view the oboe gem [source code documentation for this
-feature](https://github.com/tracelytics/ruby-appoptics/blob/master/lib/appoptics/config.rb#L129).

data/examples/carrying_context.rb

@@ -1,220 +0,0 @@
-###############################################################
-# A brief overview of AppOpticsAPM tracing context
-###############################################################
-#
-# Tracing context is the state held when AppOpticsAPM is instrumenting a
-# transaction, block, request etc..  This context is advanced as
-# new blocks are instrumented and this chain of context is used
-# by AppOpticsAPM to later reassemble performance data to be displayed
-# in the AppOptics dashboard.
-#
-# Tracing context is non-existent until established by calling
-# `AppOpticsAPM::API.start_trace` or `AppOpticsAPM::API.log_start`.  Those methods
-# are part of the high-level and low-level API respectively.
-#
-# After a tracing context is established, that context can be
-# continued by calling `AppOpticsAPM::API.trace` or `AppOpticsAPM::API.log_entry`.
-# These methods will advance an existing context but not start
-# new one.
-#
-# For example, when a web request comes into a stack, a tracing
-# context is established using `AppOpticsAPM::API.log_start` as the request
-# enters through the rack middleware via `::AppOpticsAPM::Rack`.
-#
-# That tracing context is then continued using `AppOpticsAPM::API.trace` or
-# `AppOpticsAPM::API.log_entry` for each subsequent layer such as Rails,
-# ActiveRecord, Redis, Memcache, ActionView, Mongo (etc...) until
-# finally request processing is complete and the tracing context
-# is cleared (AppOpticsAPM::Context.clear)
-#
-
-###############################################################
-# Carrying Context
-###############################################################
-#
-# The tracing context exists in the form of an X-Trace string and
-# can be retrieved using 'AppOpticsAPM::Context.toString'
-#
-# xtrace = AppOpticsAPM::Context.toString
-#
-# => "1B4EDAB9E028CA3C81BCD57CC4644B4C4AE239C7B713F0BCB9FAD6D562"
-#
-# Tracing context can also be picked up from a pre-existing
-# X-Trace string:
-#
-# xtrace = "1B4EDAB9E028CA3C81BCD57CC4644B4C4AE239C7B713F0BCB9FAD6D562"
-#
-# AppOpticsAPM::Context.fromString(xtrace)
-#
-# With these two methods, context can be passed across threads,
-# processes (via fork) and in requests (such as external HTTP
-# requests where the X-Trace is inserted in request headers).
-#
-#
-
-###############################################################
-# Two Options for Spawned Tracing
-###############################################################
-#
-# When your application needs to instrument code that forks,
-# spawns a thread or does something in-parallel, you have the
-# option to either link those child traces to the parent or
-# trace them as individuals (but with identifying information).
-#
-# Linking parent and child has it's benefits as in the
-# AppOptics dashboard, you will see how a process may spawn
-# a task in parallel and in a single view see the performance
-# of both.
-#
-# The limitation of this is that this is only useful if your
-# parent process spawns only a limited number of child traces.
-#
-# If your parent process is spawning many child tasks (e.g.
-# twenty, hundreds, thousands or more) it's best to trace those
-# child tasks as individuals and pass in identifier Key-Values
-# (such as task ID, job ID etc..)
-#
-# In the examples below, I show implementations of both linked
-# asynchronous traces and separated independent traces.
-
-###############################################################
-# Thread - with separated traces
-###############################################################
-
-AppOpticsAPM::API.log_start('parent')
-
-# Get the work to be done
-job = get_work
-
-Thread.new do
-  # This is a new thread so there is no pre-existing context so
-  # we'll call `AppOpticsAPM::API.log_start` to start a new trace context.
-  AppOpticsAPM::API.log_start('worker_thread', :job_id => job.id)
-
-  # Do the work
-  do_the_work(job)
-
-  AppOpticsAPM::API.log_end('worker_thread')
-end
-
-AppOpticsAPM::API.log_end('parent')
-
-###############################################################
-#
-# This will generate two independent traces with the following
-# topology.
-#
-# 'parent'
-# ------------------------------------------------------------
-#
-# 'worker_thread'
-# ------------------------------------------------------------
-#
-
-###############################################################
-# Thread - with linked asynchronous traces
-###############################################################
-
-# Since the following example spawns a thread without waiting
-# for it to return, we carry over the context and we mark the
-# trace generated in that thread to be asynchronous using
-# the `Async` flag.
-
-AppOpticsAPM::API.log_start('parent')
-
-# Save the context to be imported in spawned thread
-tracing_context = AppOpticsAPM::Context.toString
-
-# Get the work to be done
-job = get_work
-
-Thread.new do
-  # Restore context
-  AppOpticsAPM::Context.fromString(tracing_context)
-
-  AppOpticsAPM::API.log_entry('worker_thread')
-
-  # Do the work
-  do_the_work(job)
-
-  AppOpticsAPM::API.log_exit('worker_thread', :Async => 1)
-end
-
-AppOpticsAPM::API.log_end('parent')
-
-###############################################################
-#
-# This will generate a single trace with an asynchronous
-# branch like the following
-#
-# 'parent'
-# ------------------------------------------------------------
-#     \
-#      \
-#       ------------------------------------------------------
-#        'worker_thread'
-#
-
-###############################################################
-# Process via fork - with separated traces
-###############################################################
-
-AppOpticsAPM::API.start_trace('parent_process') do
-  # Get some work to process
-  job = get_job
-
-  # fork process to handle work
-  fork do
-    # Since fork does a complete process copy, the tracing_context still exists
-    # so we have to clear it and start again.
-    AppOpticsAPM::Context.clear
-
-    AppOpticsAPM::API.start_trace('worker_process', nil, :job_id => job.id) do
-      do_work(job)
-    end
-  end
-
-end
-
-###############################################################
-#
-# This will generate two independent traces:
-#
-# 'parent_process'
-# ------------------------------------------------------------
-#
-# 'worker_process'
-# ------------------------------------------------------------
-#
-###############################################################
-# Process via fork - with linked asynchronous traces
-###############################################################
-
-AppOpticsAPM::API.start_trace('parent_process') do
-  # Get some work to process
-  job = get_job
-
-  # fork process to handle work
-  fork do
-    # Since fork does a complete process copy, the tracing_context still exists
-    # although we'll have to mark these traces as asynchronous to denote
-    # that it has split off from the main program flow
-
-    AppOpticsAPM::API.trace('worker_process', :Async => 1) do
-      do_work(job)
-    end
-  end
-end
-
-###############################################################
-#
-# This will generate a single trace with an asynchronous
-# branch like the following
-#
-# 'parent_process'
-# ------------------------------------------------------------
-#     \
-#      \
-#       ------------------------------------------------------
-#        'worker_process'
-#

data/examples/instrumenting_metal_controller.rb

@@ -1,8 +0,0 @@
-class MetalController < ActionController::Metal
-  def index
-    self.response_body = 'Hello Metal!'
-  end
-
-  include AppOpticsAPMMethodProfiling
-  profile_method :index, 'metal-index'
-end

data/examples/puma_on_heroku_config.rb

@@ -1,17 +0,0 @@
-workers Integer(ENV['WEB_CONCURRENCY'] || 2)
-threads_count = Integer(ENV['MAX_THREADS'] || 5)
-threads threads_count, threads_count
-
-preload_app!
-
-rackup      DefaultRackup
-port        ENV['PORT']     || 3000
-environment ENV['RACK_ENV'] || 'development'
-
-on_worker_boot do
-  ::AppOpticsAPM.reconnect! if defined?(::AppOpticsAPM)
-end
-
-on_worker_shutdown do
-  ::AppOpticsAPM.disconnect! if defined?(::AppOpticsAPM)
-end

data/examples/tracing_async_threads.rb

@@ -1,124 +0,0 @@
-#
-# This sample demonstrates how to instrument a main loop that
-# retrieves work and spawn threads that 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 |j|
-
-      # In the new Thread block, the AppOpticsAPM tracing context isn't there
-      # so we carry it over manually and pass it to the `start_trace`
-      # method.
-
-      # In the AppOptics dashboard, this will show up as parent traces
-      # (layer 'get_the_work') with child traces (layer 'do_the_work').
-
-      tracing_context = AppOpticsAPM::Context.toString
-
-      Thread.new do
-        result = nil
-
-        AppOpticsAPM::API.start_trace('do_the_work', tracing_context, :Async => 1) do
-          result = do_the_work(j)
-        end
-
-        result
-      end
-    end
-  end
-  sleep 5
-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
-####################################################
-
-# The above code generates a trace for each loop of the parent data collection process.
-# Those traces have the layer name of `get_the_work` and will show up in the AppOptics
-# dashboard as such.
-#
-# Then as threads are spawned to process individual bits of work, we carry over the
-# `tracing_context` and start a new asynchronous trace using `start_trace`.  (An
-# asynchronous trace is noted by passing the `Async` Hash key with a value of `1`).
-#
-# In the AppOptics dashboard, the two traces (parent and child; or one to many) will
-# be linked and displayed together as a single trace.
-
-####################################################
-# Caveats
-####################################################
-
-# If the main loop is retrieving many jobs (work) to process on each loop then
-# linking the traces may not be the best strategy as such large relationships
-# are difficult to display correctly in the AppOptics dashboard and provide little
-# added value.
-#
-# If there are more than 8 - 12 threads spawned from each loop, then you may want to consider
-# NOT carrying over tracing context into the spawned threads.
-#
-# In this case, you can simply omit `tracing_context` and passing it to `start_trace` in
-# the `Thread.new` block. (lines 32 + 37).  Also remove the `{ Async => 1 }` Hash!
-#
-# This will produce two sets of traces with two the layer names 'get_the_work' +
-# 'do_the_work'.
-#
-# In the AppOptics dashboard, you can then separate or unify these traces into
-# independent applications.  e.g. job processor, data retrieval, thread worker etc...
-#
-# An implementation of the work loop without carrying over tracing context would look
-# like the following:
-#
-#    work.each do |j|
-#      Thread.new do
-#        result = nil
-#
-#        AppOpticsAPM::API.start_trace('do_the_work') do
-#          result = do_the_work(j)
-#        end
-#
-#        result
-#      end
-#    end
-#
-# If anything isn't clear, please don't hesitate to reach us at support (support@appoptics.com).
-#

data/examples/tracing_background_jobs.rb

@@ -1,53 +0,0 @@
-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

@@ -1,99 +0,0 @@
-#
-# 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

@@ -1,28 +0,0 @@
-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