oboe 2.7.18-java → 2.7.19-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93ba6ca6e90578dc3c4452920f4f5cbe273e47f3
-  data.tar.gz: 5c384c3787a643649687e0de6fa097bcc458421b
+  metadata.gz: 33955fe50b8e7ee846ccb2ceb23a941c9234ecff
+  data.tar.gz: 4853c7efeaecad88636fed0ffad00f776078bc15
 SHA512:
-  metadata.gz: 2297117842076a4a8bb0c688c24e6b0ac7259fa70eff8c587e2353a942cb3e9f6416f82556270e057fe2efedf55c5a6c1d03790bc1b4b2dbab3e4cc6196c3ed7
-  data.tar.gz: 18859da8ba47dbcb043b2439deaaea40ce41556edb606fcb4e3ee307b226ad70459e8ad48c583be88c53a99f004b1b2feef14d55e17d553767faf6ae4dda5573
+  metadata.gz: 4cf1195690e7cb9c9ba6a6ef6de3f965a8c6ea4300fc7536b99020423167314b3b57bfbe10f8b66efa87961296a8741807c18fc6888cd507654ffffce2541e49
+  data.tar.gz: 732866a1c7932065e6c32f12d97c12e2251ba16abf21043447ed1a57bfc40dd7a5d15390bf0e0b59918f5513fabb14eea03db285e5e1418d41c51d6d623526b5

data/.gitignore

@@ -1,4 +1,6 @@
 oboe*.gem
+Gemfile.lock
+.ruby-version
 *~
 *.swp
 lib/oboe_metal.so

data/CHANGELOG.md

@@ -4,6 +4,26 @@ https://github.com/appneta/oboe-ruby/releases
 
 Dates in this file are in the format MM/DD/YYYY.
 
+# oboe 2.7.19
+
+__Note that this will be the last release for the oboe gem.   The gem
+will be renamed to _traceview_ and all future updates will be to that
+other gem.__
+
+This version will show a post-install warning message stating this.  A
+final version of this gem will be released with only a deprecation
+warning.
+
+This patch release includes the following fix:
+
+* Report TraceMode in __Init: #120
+* Add RemoteHost reporting to Dalli Instrumentation: #119
+
+Pushed to Rubygems:
+
+https://rubygems.org/gems/oboe/versions/2.7.19
+https://rubygems.org/gems/oboe/versions/2.7.19-java
+
 # oboe 2.7.18
 
 This patch release includes the following fix:

data/README.md

@@ -9,6 +9,7 @@ It has the ability to report performance metrics on an array of libraries, datab
 
 It requires a [TraceView](http://www.appneta.com/products/traceview/) account to view metrics.  Get yours, [it's free](http://www.appneta.com/products/traceview-free-account/).
 
+[![Oboe API Documentation](https://www.omniref.com/ruby/gems/oboe.png)](https://www.omniref.com/ruby/gems/oboe)
 [![Gem Version](https://badge.fury.io/rb/oboe.png)](http://badge.fury.io/rb/oboe)
 [![Build Status](https://travis-ci.org/appneta/oboe-ruby.png?branch=master)](https://travis-ci.org/appneta/oboe-ruby)
 [![Code Climate](https://codeclimate.com/github/appneta/oboe-ruby.png)](https://codeclimate.com/github/appneta/oboe-ruby)

data/examples/DNT.md

@@ -0,0 +1,35 @@
+By default, the TraceView oboe 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
+`Oboe::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 `Oboe::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):
+
+    Oboe::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/appneta/oboe-ruby/blob/master/lib/oboe/config.rb#L74).

data/examples/carrying_context.rb

@@ -0,0 +1,225 @@
+###############################################################
+# A brief overview of TraceView tracing context
+###############################################################
+#
+# Tracing context is the state held when TraceView is instrumenting a
+# transaction, block, request etc..  This context is advanced as
+# new blocks are instrumented and this chain of context is used
+# by TraceView to later reassemble performance data to be displayed
+# in the TraceView dashboard.
+#
+# Tracing context is non-existent until established by calling
+# `Oboe::API.start_trace` or `Oboe::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 `Oboe::API.trace` or `Oboe::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 `Oboe::API.log_start` as the request
+# enters through the rack middleware via `::Oboe::Rack`.
+#
+# That tracing context is then continued using `Oboe::API.trace` or
+# `Oboe::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 (Oboe::Context.clear)
+#
+
+###############################################################
+# Carrying Context
+###############################################################
+#
+# The tracing context exists in the form of an X-Trace string and
+# can be retrieved using 'Oboe::Context.toString'
+#
+# xtrace = Oboe::Context.toString
+#
+# => "1B4EDAB9E028CA3C81BCD57CC4644B4C4AE239C7B713F0BCB9FAD6D562"
+#
+# Tracing context can also be picked up from a pre-existing
+# X-Trace string:
+#
+# xtrace = "1B4EDAB9E028CA3C81BCD57CC4644B4C4AE239C7B713F0BCB9FAD6D562"
+#
+# Oboe::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
+# TraceView 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
+###############################################################
+
+Oboe::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 `Oboe::API.log_start` to start a new trace context.
+  Oboe::API.log_start('worker_thread', { :job_id => job.id })
+
+  # Do the work
+  do_the_work(job)
+
+  Oboe::API.log_end('worker_thread')
+end
+
+Oboe::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.
+
+Oboe::API.log_start('parent')
+
+# Save the context to be imported in spawned thread
+tracing_context = Oboe::Context.toString
+
+# Get the work to be done
+job = get_work
+
+Thread.new do
+  # Restore context
+  Oboe::Context.fromString(tracing_context)
+
+  Oboe::API.log_entry('worker_thread')
+
+  # Do the work
+  do_the_work(job)
+
+  Oboe::API.log_exit('worker_thread', { 'Async' => 1 })
+end
+
+Oboe::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
+###############################################################
+
+Oboe::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.
+    Oboe::Context.clear
+
+    Oboe::API.start_trace('worker_process', { :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
+###############################################################
+
+Oboe::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
+
+    Oboe::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

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

data/examples/puma_on_heroku_config.rb

@@ -0,0 +1,17 @@
+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
+  ::Oboe.reconnect! if defined?(::Oboe)
+end
+
+on_worker_shutdown do
+  ::Oboe.disconnect! if defined?(::Oboe)
+end

data/examples/tracing_async_threads.rb

@@ -0,0 +1,125 @@
+#
+# This sample demonstrates how to instrument a main loop that
+# retrieves work and spawn threads that do the actual work
+#
+
+require 'math'
+require 'oboe'
+
+Oboe::Config[:tracing_mode] = :always
+Oboe::Config[:verbose] = true
+
+# The parent process/loop which collects data
+while true do
+
+  # For each loop, we instrument the work retrieval.  These traces
+  # will show up as layer 'get_the_work'.
+  Oboe::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 Oboe tracing context isn't there
+      # so we carry it over manually and pass it to the `start_trace`
+      # method.
+
+      # In the TraceView dashboard, this will show up as parent traces
+      # (layer 'get_the_work') with child traces (layer 'do_the_work').
+
+      tracing_context = Oboe::Context.toString
+
+      Thread.new do
+        result = nil
+
+        Oboe::API.start_trace('do_the_work', tracing_context, { 'Async' => 1 }) do
+          result = do_the_work(j)
+        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
+####################################################
+
+# 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 TraceView
+# 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 TraceView 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 TraceView 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 TraceView 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
+#
+#        Oboe::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 (traceviewsupport@appneta.com)
+# or on IRC #appneta @ freenode.
+#

data/examples/tracing_background_jobs.rb

@@ -0,0 +1,52 @@
+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', 'through' (to follow upstream) or 'always'
+Oboe::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
+# Oboe::Ruby.load
+
+# Some KVs to report to the dashboard
+report_kvs = {}
+report_kvs[:command_line_params] = ARGV.to_s
+report_kvs[:user_id] = `whoami`
+
+Oboe::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 TV dashboard, this will show
+    # up as a large 'my_background_job' parent layer with many
+    # child 'task" layers.
+    Oboe::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.  Details in RubyDoc:
+# https://www.omniref.com/ruby/gems/oboe/2.7.10.1/symbols/Oboe::API::Tracing#tab=Methods
+
+

data/examples/tracing_forked_processes.rb

@@ -0,0 +1,100 @@
+#
+# This sample demonstrates how to instrument a main loop that
+# retrieves work and calls fork to do the actual work
+#
+
+require 'math'
+require 'oboe'
+
+Oboe::Config[:tracing_mode] = :always
+Oboe::Config[:verbose] = true
+
+# The parent process/loop which collects data
+while true do
+
+  # For each loop, we instrument the work retrieval.  These traces
+  # will show up as layer 'get_the_work'.
+  Oboe::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 `Oboe::API.start_trace`.
+        Oboe::Context.clear
+        result = nil
+
+        Oboe::API.start_trace('do_the_work', :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 TraceView dashboard.
+#
+# To do this:
+#   1. Don't clear the context in the child process
+#   2. Use `Oboe::API.trace` instead
+#   3. Pass the `Async` flag to mark this child as asynchronous
+#
+while true do
+  Oboe::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 `Oboe::API.trace` instead
+        # 3 Pass the Async flag
+        Oboe::API.trace('do_the_work', { :job_id => job.id, 'Async' => 1 }) do
+          result = do_the_work(job)
+        end
+
+        result
+      end
+    end
+  end
+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?(::Oboe) and
+    ::Oboe.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?(::Oboe) and
+    ::Oboe.reconnect!
+end

data/lib/oboe/inst/dalli.rb

@@ -25,15 +25,23 @@ module Oboe
       def perform_with_oboe(*all_args, &blk)
         op, key, *args = *all_args
 
+        report_kvs = {}
+        report_kvs[:KVOp] = op
+        report_kvs[:KVKey] = key
+        if @servers.is_a?(Array) && !@servers.empty?
+          report_kvs[:RemoteHost] = @servers.join(", ")
+        end
+
         if Oboe.tracing? && !Oboe.tracing_layer_op?(:get_multi)
-          Oboe::API.trace('memcache', { :KVOp => op, :KVKey => key }) do
+          Oboe::API.trace('memcache', report_kvs) do
             result = perform_without_oboe(*all_args, &blk)
 
-            info_kvs = {}
-            info_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
-            info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:dalli][:collect_backtraces]
+            # Clear the hash for a potential info event
+            report_kvs.clear
+            report_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
+            report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:dalli][:collect_backtraces]
 
-            Oboe::API.log('memcache', 'info', info_kvs) unless info_kvs.empty?
+            Oboe::API.log('memcache', 'info', report_kvs) unless report_kvs.empty?
             result
           end
         else
@@ -49,6 +57,9 @@ module Oboe
         begin
           info_kvs[:KVKeyCount] = keys.flatten.length
           info_kvs[:KVKeyCount] = (info_kvs[:KVKeyCount] - 1) if keys.last.is_a?(Hash) || keys.last.nil?
+          if @servers.is_a?(Array) && !@servers.empty?
+            info_kvs[:RemoteHost] = @servers.join(", ")
+          end
         rescue
           Oboe.logger.debug "[oboe/debug] Error collecting info keys: #{e.message}"
           Oboe.logger.debug e.backtrace

data/lib/oboe/util.rb

@@ -172,6 +172,7 @@ module Oboe
           platform_info['Ruby.Version']            = RUBY_VERSION
           platform_info['Ruby.Oboe.Version']       = ::Oboe::Version::STRING
           platform_info['RubyHeroku.Oboe.Version'] = ::OboeHeroku::Version::STRING if defined?(::OboeHeroku)
+          platform_info['Ruby.TraceMode.Version']  = ::Oboe::Config[:tracing_mode]
 
           # Report the framework in use
           if defined?(::RailsLts)

data/lib/oboe/version.rb

@@ -8,7 +8,7 @@ module Oboe
   module Version
     MAJOR = 2
     MINOR = 7
-    PATCH = 18
+    PATCH = 19
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/oboe.gemspec

@@ -12,7 +12,11 @@ Gem::Specification.new do |s|
   s.email = %q{traceviewsupport@appneta.com}
   s.homepage = %q{http://www.appneta.com/products/traceview/}
   s.summary = %q{AppNeta TraceView performance instrumentation gem for Ruby}
-  s.description = %q{The oboe gem provides TraceView instrumentation for MRI Ruby, JRuby and related frameworks.}
+  s.description = %q{
+The oboe gem provides TraceView instrumentation for MRI Ruby, JRuby and related frameworks.
+
+Note that this gem has been deprecated and all future updates will be relases as the 'traceview' gem.
+}
 
   s.extra_rdoc_files = ["LICENSE"]
   s.files = `git ls-files`.split("\n")
@@ -25,5 +29,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rake', '>= 0')
 
   s.required_ruby_version = '>= 1.8.6'
+
+  s.post_install_message = File.read('./rename_warning.txt')
 end
 

data/test/instrumentation/dalli_test.rb

@@ -36,6 +36,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
     traces[1].has_key?("KVKey").must_equal true
     traces[1]['Layer'].must_equal "memcache"
     traces[1]['KVKey'].must_equal "some_key"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
   end
 
   it 'should trace get' do
@@ -50,6 +51,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "get"
     traces[1]['KVKey'].must_equal "some_key"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
     traces[2]['Label'].must_equal "info"
     traces[2].has_key?('KVHit').must_equal true
     traces[3]['Label'].must_equal "exit"
@@ -67,6 +69,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "get_multi"
     traces[2]['Label'].must_equal "info"
+    traces[2]['RemoteHost'].must_equal "127.0.0.1:11211"
     traces[2].has_key?('KVKeyCount').must_equal true
     traces[2].has_key?('KVHitCount').must_equal true
     traces[3]['Label'].must_equal "exit"
@@ -86,6 +89,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "incr"
     traces[1]['KVKey'].must_equal "dalli_key_counter"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
     traces[2]['Label'].must_equal "exit"
   end
 
@@ -103,6 +107,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "decr"
     traces[1]['KVKey'].must_equal "dalli_key_counter"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
     traces[2]['Label'].must_equal "exit"
   end
 
@@ -120,6 +125,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "replace"
     traces[1]['KVKey'].must_equal "some_key"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
     traces[2]['Label'].must_equal "exit"
   end
 
@@ -137,6 +143,7 @@ describe Oboe::Inst::Dalli < ::MiniTest::Spec  do
 
     traces[1]['KVOp'].must_equal "delete"
     traces[1]['KVKey'].must_equal "some_key"
+    traces[1]['RemoteHost'].must_equal "127.0.0.1:11211"
   end
 
   it "should obey :collect_backtraces setting when true" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oboe
 version: !ruby/object:Gem::Version
-  version: 2.7.18
+  version: 2.7.19
 platform: java
 authors:
 - Peter Giacomo Lombardo
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -39,7 +39,11 @@ dependencies:
         version: '0'
   prerelease: false
   type: :development
-description: The oboe gem provides TraceView instrumentation for MRI Ruby, JRuby and related frameworks.
+description: |2
+
+  The oboe gem provides TraceView instrumentation for MRI Ruby, JRuby and related frameworks.
+
+  Note that this gem has been deprecated and all future updates will be relases as the 'traceview' gem.
 email: traceviewsupport@appneta.com
 executables: []
 extensions: []
@@ -56,6 +60,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- 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/noop/noop.c
 - ext/oboe_metal/src/bson/bson.h
@@ -173,7 +185,44 @@ homepage: http://www.appneta.com/products/traceview/
 licenses:
 - AppNeta Open License, Version 1.0
 metadata: {}
-post_install_message:
+post_install_message: |2+
+
+  =========================================================================
+  AppNeta TraceView
+
+  Note that this will be the final release for the oboe gem.  The gem
+  will be renamed to 'traceview' and all future updates will be made
+  to that other gem.
+
+  Please update your Gemfiles by replacing the 'oboe' gem with the
+  'traceview' gem.
+
+  Gemfile:
+  XXX   gem 'oboe'
+  -->   gem 'traceview'
+
+  Any Oboe specific calls will still work as usual in the new gem
+  although a single deprecation warning will be output on the
+  first use call.
+
+  We will support these legacy calls for a minimum of 1 year but
+  possibly indefinitely.
+
+  Oboe calls can be updated to use the TraceView module instead:
+
+    Oboe::Config           --> TraceView::Config
+    Oboe::API              --> TraceView::API
+    OboeMethodProfiling    --> TraceViewMethodProfiling
+    Oboe::Context          --> TraceView::Context
+
+  Thanks for using TraceView!  Happy tracing!
+
+  Best,
+  The TraceView Team
+
+  tldr; The gem is being renamed to traceview.  Update your Gemfiles!
+  =========================================================================
+
 rdoc_options: []
 require_paths:
 - lib