oboe 2.5.0.7 → 2.6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 812e394b380905601c8d1fbae241aaedce6231b4
-  data.tar.gz: 317bb57275d9eb6b23054d9d2e51dd0c8fbd64d6
+  metadata.gz: bf5cf2103662335b54454808e24505e4c0fe01ac
+  data.tar.gz: 0e18b3bac19c85fbfba7a34c38c7edb28bb0f53b
 SHA512:
-  metadata.gz: af3e85508ec28a8a56e05ebed1f1ee6a90c8475ca258c9b9127ee81c8d33226331f4604f856426cb1aca24b90592f7d0ec22e2c6da0df4d47e3e30a0e96f4294
-  data.tar.gz: a8744c90e5d216672d774b094deadf1d1ccf031a25de3f262984c10d83593fb5908fdb05527671ee7a53f99b5719c9238f65cea6965c197861815cf482970d86
+  metadata.gz: 94c63bc3a414703e1f29c2890a077af2c752dbcbd6f8de2e229b982802fa0b226d06186f8a0c8c5af54a526263c9dceb5f2074d64911f2420ba1ee595f5f0642
+  data.tar.gz: a7519e0aded683d91e0cf088d82a12349183616c3dec0b27beb97d969df0fa7e54df7b47c63120078c7743cddf72bd1b6a5730be608fe2e794f985b98b6fbda1

data/Gemfile

@@ -1,9 +1,5 @@
 source 'https://rubygems.org'
 
-# Import dependencies from oboe.gemspec
-gemspec :name => 'oboe'
-
-
 group :development, :test do
   gem 'minitest'
   gem 'minitest-reporters'
@@ -12,7 +8,7 @@ group :development, :test do
   gem 'bson'
 end
 
-group :development do
+group :development, :test do
   gem 'ruby-debug',   :platform => :mri_18
   gem 'ruby-debug19', :platform => :mri_19, :require => 'ruby-debug'
   gem 'byebug',       :platform => :mri_20 
@@ -31,3 +27,10 @@ gem 'moped' unless (RUBY_VERSION =~ /^1.8/) == 0
 gem 'resque'
 gem 'redis'
 
+# Instrumented Frameworks
+gem 'sinatra'
+gem 'padrino' unless (RUBY_VERSION =~ /^1.8/) == 0
+
+# Import dependencies from oboe.gemspec
+gemspec :name => 'oboe'
+

data/README.md

@@ -17,11 +17,15 @@ It requires a [TraceView](http://www.appneta.com/products/traceview/) account to
 
 The oboe gem is [available on Rubygems](https://rubygems.org/gems/oboe) and can be installed with:
 
-    gem install oboe
+```bash
+gem install oboe
+```
 
 or added to your bundle Gemfile and running `bundle install`:
 
-    gem 'oboe'
+```ruby
+gem 'oboe'
+```
 
 # Running
 
@@ -29,7 +33,7 @@ or added to your bundle Gemfile and running `bundle install`:
 
 No special steps are needed to instrument Ruby on Rails.  Once part of the bundle, the oboe gem will automatically detect Rails and instrument on stack initialization.
 
-_Note: You will still need to decide on your `tracing_mode` depending on whether you are running with an instrumented Apache or nginx in front of your Rails stack.  See below for more details._
+*Note: You will still need to decide on your `tracing_mode` depending on whether you are running with an instrumented Apache or nginx in front of your Rails stack.  See below for more details.*
 
 ### The Install Generator
 
@@ -37,16 +41,20 @@ The oboe gem provides a Rails generator used to seed an oboe initializer where y
 
 To run the install generator run:
 
-    bundle exec rails generate oboe:install
+```bash
+bundle exec rails generate oboe:install
+```
 
 After the prompts, this will create an initializer: `config/initializers/oboe.rb`.
 
-## Sinatra/Padrino
+## Sinatra
 
-You can instrument your Sinatra or Padrino application by adding the following code to your `config.ru` Rackup file (Padrino example).
+You can instrument your Sinatra application by adding the following code to your `config.ru` Rackup file:
 
+```ruby
+    # If you're not using Bundler.require.  Make sure this is done
+    # after the Sinatra require directive.
     require 'oboe'
-    require 'oboe/inst/rack'
     
     # When traces should be initiated for incoming requests. Valid options are
     # "always", "through" (when the request is initiated with a tracing header 
@@ -58,32 +66,57 @@ You can instrument your Sinatra or Padrino application by adding the following c
     # auto sampling or managing the sample rate through the TraceView portal.
     # Oboe::Config[:sample_rate] = 1000000
     
-    # You may want to replace the Oboe.logger with your own
-    Oboe.logger = Padrino.logger
-    
-    Oboe::Ruby.initialize
-    Padrino.use Oboe::Rack
+    # You may want to replace the Oboe.logger with whichever logger you are using
+    # Oboe.logger = Sinatra.logger
+```
+
+Note: If you're on Heroku, you don't need to set `tracing_mode` or `sample_rate` - they will be automatically configured.
+
+Make sure that the oboe gem is loaded _after_ Sinatra either by listing `gem 'oboe'` after Sinatra in your Gemfile or calling the `require 'oboe'` directive after Sinatra is loaded.
+
+With this, the oboe gem will automatically detect Sinatra on boot and instrument key components.
+
+## Padrino
+
+As long as the oboe gem is in your `Gemfile` (inserted after the `gem 'padrino'` directive) and you are calling `Bundler.require`, the oboe gem will automatically instrument Padrino applications.
+
+If you need to set `Oboe::Config` values on stack boot, you can do so by adding the following
+to your `config/boot.rb` file:
 
-_In a future release, much of this will be automated._
+    Padrino.before_load do
+      # When traces should be initiated for incoming requests. Valid options are
+      # "always", "through" (when the request is initiated with a tracing header 
+      # from upstream) and "never". You must set this directive to "always" in 
+      # order to initiate tracing.
+      Oboe::Config[:tracing_mode] = 'always'
+
+      # You can remove the following line in production to allow for
+      # auto sampling or managing the sample rate through the TraceView portal.
+      Oboe::Config[:sample_rate] = 1e6
+    end
+
+Note: If you're on Heroku, you don't need to set `tracing_mode` or `sample_rate` - they will be automatically configured.
 
 ## Custom Ruby Scripts & Applications
 
 The oboe gem has the ability to instrument any arbitrary Ruby application or script as long as the gem is initialized with the manual methods:
 
-    require 'rubygems'
-    require 'bundler'
-    
-    Bundler.require
-    
-    require 'oboe'
+```ruby
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
 
-    # Tracing mode can be 'never', 'through' (to follow upstream) or 'always'
-    Oboe::Config[:tracing_mode] = 'always'
+require 'oboe'
 
-    # Number of requests to trace out of each million
-    Oboe::Config[:sample_rate] = 1000000
+# Tracing mode can be 'never', 'through' (to follow upstream) or 'always'
+Oboe::Config[:tracing_mode] = 'always'
 
-    Oboe::Ruby.initialize
+# Number of requests to trace out of each million
+Oboe::Config[:sample_rate] = 1000000
+
+Oboe::Ruby.initialize
+```
 
 From here, you can use the Tracing API to instrument areas of code using `Oboe::API.start_trace` (see below).  If you prefer to instead dive directly into code, take a look at [this example](https://gist.github.com/pglombardo/8550713) of an instrumented Ruby script.
 
@@ -97,20 +130,22 @@ You can send deploy notifications to TraceView and have the events show up on yo
 
 You can instrument any arbitrary block of code using `Oboe::API.trace`:
 
-    # layer_name will show up in the TraceView app dashboard
-    layer_name = 'subsystemX'
+```ruby
+# layer_name will show up in the TraceView app dashboard
+layer_name = 'subsystemX'
 
-    # report_kvs are a set of information Key/Value pairs that are sent to
-    # TraceView dashboard along with the performance metrics.  These KV 
-    # pairs are used to report request, environment and/or client specific
-    # information.
+# report_kvs are a set of information Key/Value pairs that are sent to
+# TraceView dashboard along with the performance metrics.  These KV
+# pairs are used to report request, environment and/or client specific
+# information.
 
-    report_kvs = {}
-    report_kvs[:mykey] = @client.id
+report_kvs = {}
+report_kvs[:mykey] = @client.id
 
-    Oboe::API.trace(layer_name, report_kvs) do
-      # the block of code to be traced
-    end
+Oboe::API.trace(layer_name, report_kvs) do
+  # the block of code to be traced
+end
+```
 
 `Oboe::API.trace` is used within the context of a request.  It will follow the upstream state of the request being traced.  i.e. the block of code will only be traced when the parent request is being traced.
 
@@ -126,20 +161,22 @@ By using class level declarations, it's possible to automatically have certain m
 
 The pattern for Method Profiling is as follows:
 
-    # 'profile_name' is similar to a layer name.  
-    # It identifies this custom trace in your dashboard.
-    # 
-    class Engine
-        include OboeMethodProfiling
-
-        def processor()
-            # body of method
-        end
+```ruby
+# 'profile_name' is similar to a layer name.
+# It identifies this custom trace in your dashboard.
+#
+class Engine
+    include OboeMethodProfiling
 
-        # call syntax: profile_method <method>, <profile_name>
-        profile_method :processor, 'processor' 
+    def processor()
+        # body of method
     end
 
+    # call syntax: profile_method <method>, <profile_name>
+    profile_method :processor, 'processor'
+end
+```
+
 This example demonstrates method profiling of instance methods.  Class methods are profiled slightly differently.  See the TraceView [documentation portal](https://support.tv.appneta.com/support/solutions/articles/86395-ruby-instrumentation-public-api) for full details.
 
 # Support
@@ -179,7 +216,9 @@ The oboe gem uses a standard gem layout.  Here are the notable directories.
 
 The oboe gem is built with the standard `gem build` command passing in the gemspec:
 
-    gem build oboe.gemspec
+```bash
+gem build oboe.gemspec
+```
 
 ## Writing Custom Instrumentation
 
@@ -191,50 +230,54 @@ The Dalli gem nicely routes all memcache operations through a single `perform` o
 
 First, we define a module (Oboe::Inst::Dalli) and our own custom `perform_with_oboe` method that we will use as a wrapper around Dalli's `perform` method.  We also declare an `included` method which automatically gets called when this module is included by another.  See ['included' Ruby reference documentation](http://apidock.com/ruby/Module/included).
 
-    module Oboe
-      module Inst
-        module Dalli
-          include Oboe::API::Memcache
-
-          def self.included(cls)
-            cls.class_eval do
-              if ::Dalli::Client.private_method_defined? :perform
-                alias perform_without_oboe perform
-                alias perform perform_with_oboe
-              end
-            end
+```ruby
+module Oboe
+  module Inst
+    module Dalli
+      include Oboe::API::Memcache
+
+      def self.included(cls)
+        cls.class_eval do
+          if ::Dalli::Client.private_method_defined? :perform
+            alias perform_without_oboe perform
+            alias perform perform_with_oboe
           end
-          
-          def perform_with_oboe(*all_args, &blk)
-            op, key, *args = *all_args
-
-            if Oboe.tracing?
-              opts = {}
-              opts[:KVOp] = op
-              opts[:KVKey] = key
-
-              Oboe::API.trace('memcache', opts || {}) do
-                result = perform_without_oboe(*all_args, &blk)
-                if op == :get and key.class == String
-                    Oboe::API.log('memcache', 'info', { :KVHit => memcache_hit?(result) })
-                end
-                result
-              end
-            else
-              perform_without_oboe(*all_args, &blk)
+        end
+      end
+
+      def perform_with_oboe(*all_args, &blk)
+        op, key, *args = *all_args
+
+        if Oboe.tracing?
+          opts = {}
+          opts[:KVOp] = op
+          opts[:KVKey] = key
+
+          Oboe::API.trace('memcache', opts || {}) do
+            result = perform_without_oboe(*all_args, &blk)
+            if op == :get and key.class == String
+                Oboe::API.log('memcache', 'info', { :KVHit => memcache_hit?(result) })
             end
+            result
           end
+        else
+          perform_without_oboe(*all_args, &blk)
         end
       end
     end
+  end
+end
+```
 
 Second, we tail onto the end of the instrumentation file a simple `::Dalli::Client.module_eval` call to tell the Dalli module to include our newly defined instrumentation module.  Doing this will invoke our previously defined `included` method.
 
-    if defined?(Dalli) and Oboe::Config[:dalli][:enabled]
-      ::Dalli::Client.module_eval do
-        include Oboe::Inst::Dalli
-      end
-    end
+```ruby
+if defined?(Dalli) and Oboe::Config[:dalli][:enabled]
+  ::Dalli::Client.module_eval do
+    include Oboe::Inst::Dalli
+  end
+end
+```
 
 Third, in our wrapper method, we capture the arguments passed in, collect the operation and key information into a local hash and then invoke the `Oboe::API.trace` method to time the execution of the original operation.
 
@@ -248,9 +291,9 @@ Some other tips and guidelines:
 
 * If instrumenting a library, database or service, place your new instrumentation file into the `lib/oboe/inst/` directory.  From there, the oboe gem will detect it and automatically load the instrumentation file.
 
-* If instrumentating a new framework, place your instrumentation file in `lib/oboe/frameworks`.  Refer to the Rails instrumentation for on ideas on how to load the oboe gem correctly in your framework.
+* If instrumenting a new framework, place your instrumentation file in `lib/oboe/frameworks`.  Refer to the Rails instrumentation for on ideas on how to load the oboe gem correctly in your framework.
 
-* Review other existing instrumention similar to the one you wish to author.  `lib/oboe/inst/` is a great place to start.
+* Review other existing instrumentation similar to the one you wish to author.  `lib/oboe/inst/` is a great place to start.
 
 * Depending on the configured `:sample_rate`, not all requests will be traced.  Use `Oboe.tracing?` to determine of this is a request that is being traced.
 
@@ -262,21 +305,25 @@ Some other tips and guidelines:
 
 The oboe gem utilizes a C extension to interface with the system `liboboe.so` library.  This system library is installed with the TraceView host packages (tracelyzer, liboboe0, liboboe-dev) and is used to report [host](http://www.appneta.com/blog/app-host-metrics/) and performance metrics from multiple sources (Ruby, Apache, Python etc.) back to TraceView servers.
 
-C extensions are usually built on `gem install` but when working out of a local git repository, it's required that you manually build this C extension for the gem to function.  
+C extensions are usually built on `gem install` but when working out of a local git repository, it's required that you manually build this C extension for the gem to function.
 
 To make this simpler, we've included a few rake tasks to automate this process:
 
-    rake compile             # Build the gem's c extension
-    rake distclean           # Remove all built files and extensions
-    rake recompile           # Rebuild the gem's c extension
+```bash
+rake compile             # Build the gem's c extension
+rake distclean           # Remove all built files and extensions
+rake recompile           # Rebuild the gem's c extension
+```
 
 Note: Make sure you have the development package `liboboe0-dev` installed before attempting to compile the C extension.
 
-    >$ dpkg -l | grep liboboe
-    ii  liboboe-dev    1.1.1-precise1    Tracelytics common library -- development files
-    ii  liboboe0       1.1.1-precise1    Tracelytics common library
+```bash
+>$ dpkg -l | grep liboboe
+ii  liboboe-dev    1.1.1-precise1    Tracelytics common library -- development files
+ii  liboboe0       1.1.1-precise1    Tracelytics common library
+```
 
-See [Installing Base Packages on Debian and Ubuntu](https://support.tv.appneta.com/support/solutions/articles/86359-installing-base-packages-on-debian-and-ubuntu) in the Knowledge Base for details.  Our hacker extraodinaire [Rob Salmond](https://github.com/rsalmond) from the support team has even gotten these packages to [run on Gentoo](http://www.appneta.com/blog/unsupported-doesnt-work/)!
+See [Installing Base Packages on Debian and Ubuntu](https://support.tv.appneta.com/support/solutions/articles/86359-installing-base-packages-on-debian-and-ubuntu) in the Knowledge Base for details.  Our hacker extraordinaire [Rob Salmond](https://github.com/rsalmond) from the support team has even gotten these packages to [run on Gentoo](http://www.appneta.com/blog/unsupported-doesnt-work/)!
 
 To see the code related to the C extension, take a look at `ext/oboe_metal/extconf.rb` for details.
 
@@ -288,21 +335,25 @@ The tests bundled with the gem are implemented using [Minitest](https://github.c
 
 After a bundle install, the tests can be run as:
 
-    bundle exec rake test
+```bash
+bundle exec rake test
+```
 
 This will run a full end-to-end test suite that covers all supported libraries and databases.  Note that this requires all of the supported software (Cassandra, Memcache, Mongo etc.) to be installed, configured and available.
 
-Since this is overly burdonsome for casual users, you can run just the tests that you're interested in.  
+Since this is overly burdensome for casual users, you can run just the tests that you're interested in.
 
 To run just the tests for the dalli gem trace validation:
 
-    bundle exec rake test TEST=test/instrumentation/dalli_test.rb
+```bash
+bundle exec rake test TEST=test/instrumentation/dalli_test.rb
+```
 
-We humbly request that any submitted instrumention is delivered with corresponding test coverage.
+We humbly request that any submitted instrumentation is delivered with corresponding test coverage.
 
 # License
 
-Copyright (c) 2013 Appneta
+Copyright (c) 2014 Appneta
 
 Released under the [AppNeta Open License](http://www.appneta.com/appneta-license), Version 1.0
 

data/Rakefile

@@ -77,3 +77,11 @@ end
 desc "Rebuild the gem's c extension"
 task :recompile => [ :distclean, :compile ]
 
+task :console do
+  require 'pry'
+  require 'oboe'
+  ARGV.clear
+  Pry.start
+end
+
+

data/lib/oboe.rb

@@ -22,7 +22,7 @@ begin
     rescue LoadError
       Oboe.loaded = false
 
-      unless $ENV['RAILS_GROUP'] == 'assets'
+      unless ENV['RAILS_GROUP'] == 'assets'
         $stderr.puts "=============================================================="
         $stderr.puts "Missing TraceView libraries.  Tracing disabled."
         $stderr.puts "See: https://support.tv.appneta.com/solution/articles/137973" 
@@ -38,8 +38,11 @@ begin
   require 'oboe/ruby'
 
   # Frameworks
-  require 'oboe/frameworks/rails' if defined?(::Rails) and Oboe.loaded
-
+  if Oboe.loaded
+    require 'oboe/frameworks/rails'   if defined?(::Rails)
+    require 'oboe/frameworks/sinatra' if defined?(::Sinatra)
+    require 'oboe/frameworks/padrino' if defined?(::Padrino)
+  end
 rescue Exception => e
   $stderr.puts "[oboe/error] Problem loading: #{e.inspect}"
   $stderr.puts e.backtrace

data/lib/oboe/frameworks/padrino.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2014 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module PadrinoInst
+    module Routing
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+      end
+
+      def dispatch_with_oboe
+        if Oboe.tracing?
+          report_kvs = {}
+
+          # Fall back to the raw tracing API so we can pass KVs
+          # back on exit (a limitation of the Oboe::API.trace
+          # block method) This removes the need for an info
+          # event to send additonal KVs
+          ::Oboe::API.log_entry('padrino', {})
+
+          begin
+            r = dispatch_without_oboe
+
+            # Report Controller/Action as best possible
+            if request.controller and not request.controller.empty?
+              report_kvs[:Controller] = request.controller
+            else
+              report_kvs[:Controller] = self.class
+            end
+
+            report_kvs[:Action] = request.action
+            r
+           ensure
+            ::Oboe::API.log_exit('padrino', report_kvs)
+           end
+        else
+          dispatch_without_oboe
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Padrino)
+  # This instrumentation is a superset of the Sinatra instrumentation similar 
+  # to how Padrino is a superset of Sinatra itself.
+  ::Oboe.logger.info "[oboe/loading] Instrumenting Padrino" if Oboe::Config[:verbose]
+
+  require 'oboe/frameworks/padrino/templates'
+
+  Padrino.after_load do
+    ::Oboe.logger = ::Padrino.logger if ::Padrino.respond_to?(:logger)
+    ::Oboe::Loading.load_access_key
+    ::Oboe::Inst.load_instrumentation
+
+    ::Oboe::Util.send_include(::Padrino::Routing::InstanceMethods, ::Oboe::PadrinoInst::Routing)
+    if defined?(::Padrino::Rendering)
+      ::Oboe::Util.send_include(::Padrino::Rendering::InstanceMethods, ::Oboe::PadrinoInst::Rendering)
+    end
+  end
+
+end
+

data/lib/oboe/frameworks/padrino/templates.rb

@@ -0,0 +1,57 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module PadrinoInst
+    module Rendering
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      def render_with_oboe(engine, data=nil, options={}, locals={}, &block)
+        if Oboe.tracing?
+          report_kvs = {}
+
+          if data
+            report_kvs[:engine] = engine
+            report_kvs[:template] = data
+          else
+            report_kvs[:template] = engine
+          end
+
+          if Oboe::Context.tracing_layer_op?('render')
+            # For recursive calls to :render (for sub-partials and layouts),
+            # use method profiling.
+            begin
+              report_kvs[:FunctionName] = :render
+              report_kvs[:Class]        = :Rendering
+              report_kvs[:Module]       = 'Padrino'
+              report_kvs[:File]         = __FILE__
+              report_kvs[:LineNumber]   = __LINE__
+            rescue StandardError => e
+              ::Oboe.logger.debug e.message
+              ::Oboe.logger.debug e.backtrace.join(", ")
+            end
+
+            Oboe::API.profile(report_kvs[:template], report_kvs, false) do
+              render_without_oboe(engine, data, options, locals, &block)
+            end
+          else
+            # Fall back to the raw tracing API so we can pass KVs
+            # back on exit (a limitation of the Oboe::API.trace
+            # block method) This removes the need for an info
+            # event to send additonal KVs
+            ::Oboe::API.log_entry('render', {}, 'render')
+
+            begin
+              render_without_oboe(engine, data, options, locals, &block)
+            ensure
+              ::Oboe::API.log_exit('render', report_kvs)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/oboe/frameworks/rails.rb

@@ -4,7 +4,7 @@
 module Oboe
   module Rails
     module Helpers
-      extend ActiveSupport::Concern if ::Rails::VERSION::MAJOR > 2
+      extend ActiveSupport::Concern if defined?(::Rails) and ::Rails::VERSION::MAJOR > 2
 
       @@rum_xhr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_ajax_header.js.erb')
       @@rum_hdr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_header.js.erb')
@@ -106,7 +106,8 @@ if defined?(::Rails)
         end
 
         config.after_initialize do
-          Oboe::Loading.setup_logger
+          Oboe.logger = ::Rails.logger if ::Rails.logger
+
           Oboe::Loading.load_access_key
           Oboe::Inst.load_instrumentation
           Oboe::Rails.load_instrumentation
@@ -115,7 +116,8 @@ if defined?(::Rails)
       end
     end
   else
-    Oboe::Loading.setup_logger
+    Oboe.logger = ::Rails.logger if ::Rails.logger
+
     Oboe::Rails.load_initializer
     Oboe::Loading.load_access_key
     

data/lib/oboe/frameworks/sinatra.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Sinatra
+    module Base
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :dispatch!,         ::Sinatra::Base)
+        ::Oboe::Util.method_alias(klass, :handle_exception!, ::Sinatra::Base)
+      end
+
+      def dispatch_with_oboe
+        if Oboe.tracing?
+          report_kvs = {}
+
+          report_kvs[:Controller] = self.class
+          report_kvs[:Action] = env['PATH_INFO']
+
+          # Fall back to the raw tracing API so we can pass KVs
+          # back on exit (a limitation of the Oboe::API.trace
+          # block method) This removes the need for an info
+          # event to send additonal KVs
+          ::Oboe::API.log_entry('sinatra', {})
+
+          begin
+            dispatch_without_oboe
+          ensure
+            ::Oboe::API.log_exit('sinatra', report_kvs)
+          end
+        else
+          dispatch_without_oboe
+        end
+      end
+      
+      def handle_exception_with_oboe(boom)
+        Oboe::API.log_exception(nil, boom) if Oboe.tracing?
+        handle_exception_without_oboe(boom)
+      end
+    end
+  end
+end
+
+if defined?(::Sinatra)
+  require 'oboe/inst/rack'
+  require 'oboe/frameworks/sinatra/templates'
+
+  Oboe.logger.info "[oboe/loading] Instrumenting Sinatra" if Oboe::Config[:verbose]
+
+  Oboe::Loading.load_access_key
+  Oboe::Inst.load_instrumentation
+
+  ::Sinatra::Base.use Oboe::Rack
+
+  # When in TEST environment, we load this instrumentation regardless.
+  # Otherwise, only when Padrino isn't around.
+  unless defined?(::Padrino) and not (ENV['RACK_ENV'] == "test")
+    # Padrino has 'enhanced' routes and rendering so the Sinatra 
+    # instrumentation won't work anyways.  Only load for pure Sinatra apps.
+    ::Oboe::Util.send_include(::Sinatra::Base,      ::Oboe::Sinatra::Base)
+    ::Oboe::Util.send_include(::Sinatra::Templates, ::Oboe::Sinatra::Templates)
+  end
+end
+

data/lib/oboe/frameworks/sinatra/templates.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Sinatra
+    module Templates 
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :render, ::Sinatra::Templates)
+      end
+
+      def render_with_oboe(engine, data, options = {}, locals = {}, &block)
+        if Oboe.tracing?
+          report_kvs = {}
+
+          report_kvs[:engine] = engine
+          report_kvs[:template] = data
+
+          if Oboe::Context.tracing_layer_op?('render')
+            # For recursive calls to :render (for sub-partials and layouts), 
+            # use method profiling.
+            begin
+              name = data
+              report_kvs[:FunctionName] = :render
+              report_kvs[:Class]        = :Templates
+              report_kvs[:Module]       = 'Sinatra::Templates'
+              report_kvs[:File]         = __FILE__
+              report_kvs[:LineNumber]   = __LINE__
+            rescue StandardError => e
+              ::Oboe.logger.debug e.message
+              ::Oboe.logger.debug e.backtrace.join(", ")
+            end
+
+            Oboe::API.profile(name, report_kvs, false) do
+              render_without_oboe(engine, data, options, locals, &block)
+            end
+
+          else
+            # Fall back to the raw tracing API so we can pass KVs
+            # back on exit (a limitation of the Oboe::API.trace
+            # block method) This removes the need for an info
+            # event to send additonal KVs
+            ::Oboe::API.log_entry('render', {}, 'render')
+
+            begin
+              render_without_oboe(engine, data, options, locals, &block)
+            ensure
+              ::Oboe::API.log_exit('render', report_kvs)
+            end
+          end
+        else
+          render_without_oboe(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end

data/lib/oboe/inst/http.rb

@@ -34,31 +34,33 @@ if Oboe::Config[:nethttp][:enabled]
           req['X-Trace'] = context unless blacklisted
         end
 
-        # The actual net::http call
-        resp = request_without_oboe(*args, &block)
-
-        # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
-        unless blacklisted
-          xtrace = resp.get_fields('X-Trace')
-          xtrace = xtrace[0] if xtrace and xtrace.is_a?(Array)
-
-          if Oboe::XTrace.valid?(xtrace) and Oboe.tracing? 
-
-            # Assure that we received back a valid X-Trace with the same task_id
-            if task_id == Oboe::XTrace.task_id(xtrace)
-              Oboe::Context.fromString(xtrace)
-            else
-              Oboe.logger.debug "Mismatched returned X-Trace ID : #{xtrace}"
+        begin
+          # The actual net::http call
+          resp = request_without_oboe(*args, &block)
+
+          # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+          unless blacklisted
+            xtrace = resp.get_fields('X-Trace')
+            xtrace = xtrace[0] if xtrace and xtrace.is_a?(Array)
+
+            if Oboe::XTrace.valid?(xtrace) and Oboe.tracing? 
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == Oboe::XTrace.task_id(xtrace)
+                Oboe::Context.fromString(xtrace)
+              else
+                Oboe.logger.debug "Mismatched returned X-Trace ID : #{xtrace}"
+              end
             end
           end
-        end
+          
+          opts['HTTPStatus'] = resp.code
         
-        opts['HTTPStatus'] = resp.code
-
-        # Log the info event with the KVs in opts
-        Oboe::API.log('net-http', 'info', opts)
-
-        next resp
+          next resp
+        ensure
+          # Log the info event with the KVs in opts
+          Oboe::API.log('net-http', 'info', opts)
+        end
       end
     end
 

data/lib/oboe/inst/rack.rb

@@ -71,7 +71,7 @@ module Oboe
       xtrace = e.instance_variable_get(:@xtrace)
       raise
     ensure
-      result[1]['X-Trace'] = xtrace if Oboe::XTrace.valid?(xtrace)
+      result[1]['X-Trace'] = xtrace if result and Oboe::XTrace.valid?(xtrace)
       return result
     end
   end

data/lib/oboe/loading.rb

@@ -37,12 +37,6 @@ module Oboe
   # instrumented libraries are already loaded...
   #
   module Loading
-    def self.setup_logger
-      if defined?(::Rails) and ::Rails.logger
-        Oboe.logger = ::Rails.logger
-      end
-    end
-
     ##
     # Load the TraceView access key (either from system configuration file
     # or environment variable) and calculate internal RUM ID
@@ -55,7 +49,7 @@ module Oboe
           Oboe::Config[:rum_id] = Oboe::Util::Base64URL.encode(Digest::SHA1.digest("RUM" + Oboe::Config[:access_key]))
         else
           # ..else read from system-wide configuration file
-          unless Oboe::Config.access_key
+          if Oboe::Config.access_key.empty?
             config_file = '/etc/tracelytics.conf'
             return unless File.exists?(config_file)
             
@@ -90,25 +84,9 @@ module Oboe
         Oboe.logger.fatal "[oboe/error] Couldn't load oboe api."
       end
     end
-
-    ## 
-    # Load instrumentation for the various frameworks located in
-    # lib/oboe/frameworks/*/*.rb
-    # 
-    def self.load_framework_instrumentation
-      pattern = File.join(File.dirname(__FILE__), 'frameworks/*/', '*.rb')
-      Dir.glob(pattern) do |f|
-        begin
-          require f
-        rescue => e
-          Oboe.logger.error "[oboe/loading] Error loading framework file '#{f}' : #{e}"
-        end
-      end
-    end
   end
 end
 
 Oboe::Loading.require_api
-Oboe::Loading.load_framework_instrumentation
 Oboe::Reporter.start
 

data/lib/oboe/util.rb

@@ -23,9 +23,22 @@ module Oboe
         end
 
         if cls.method_defined? method.to_sym or cls.private_method_defined? method.to_sym
-          cls.class_eval do
-            alias_method "#{method}_without_oboe", "#{method}"
-            alias_method "#{method}", "#{method}_with_oboe"
+          
+          # Strip '!' or '?' from method if present
+          safe_method_name = method.to_s.chop if method.to_s =~ /\?$|\!$/
+          safe_method_name ||= method
+
+          without_oboe = "#{safe_method_name}_without_oboe"
+          with_oboe    = "#{safe_method_name}_with_oboe"
+       
+          # Only alias if we haven't done so already
+          unless cls.method_defined? without_oboe.to_sym or 
+            cls.private_method_defined? without_oboe.to_sym
+
+            cls.class_eval do
+              alias_method without_oboe, "#{method}"
+              alias_method "#{method}", with_oboe
+            end
           end
         else Oboe.logger.warn "[oboe/loading] Couldn't properly instrument #{name}.  Partial traces may occur."
         end

data/lib/oboe/version.rb

@@ -4,9 +4,9 @@
 module Oboe
   module Version
     MAJOR = 2
-    MINOR = 5
+    MINOR = 6 
     PATCH = 0
-    BUILD = 7
+    BUILD = 2 
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/lib/oboe/xtrace.rb

@@ -12,6 +12,9 @@ module Oboe
       #
       def valid?(xtrace)
         begin
+          # Shouldn't be nil
+          return false unless xtrace
+
           # The X-Trace ID shouldn't be an initialized empty ID
           return false if (xtrace =~ /^1b0000000/i) == 0
 

data/test/frameworks/apps/padrino_simple.rb

@@ -1,3 +1,5 @@
+# This test Padrino stack file was taken from the padrino-core gem.
+#
 PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
 # Remove this comment if you want do some like this: ruby PADRINO_ENV=test app.rb
 #

data/test/frameworks/apps/sinatra_simple.rb

@@ -0,0 +1,20 @@
+require 'sinatra'
+
+class SinatraSimple < Sinatra::Base
+  set :reload, true
+  
+  get "/" do
+    'The magick number is: 2767356926488785838763860464013972991031534522105386787489885890443740254365!' # Change only the number!!!
+  end
+
+  get "/rand" do
+    rand(2 ** 256).to_s
+  end
+
+  get "/render" do
+    render :erb, "This is an erb render"
+  end
+end
+
+use SinatraSimple
+

data/test/frameworks/padrino_test.rb

@@ -0,0 +1,25 @@
+unless (RUBY_VERSION =~ /^1.8/) == 0
+  require "minitest_helper"
+  require File.expand_path(File.dirname(__FILE__) + '/apps/padrino_simple')
+
+  describe Padrino do
+    before do
+      clear_all_traces 
+    end
+
+    it "should trace a request to a simple padrino stack" do
+      @app = SimpleDemo
+      
+      r = get "/render"
+      
+      traces = get_all_traces
+      traces.count.must_equal 9
+
+      validate_outer_layers(traces, 'rack')
+
+      traces[1]['Layer'].must_equal "padrino"
+      traces[6]['Controller'].must_equal "SimpleDemo"
+      traces[7]['Label'].must_equal "info"
+    end
+  end
+end

data/test/frameworks/sinatra_test.rb

@@ -0,0 +1,25 @@
+require "minitest_helper"
+require File.expand_path(File.dirname(__FILE__) + '/apps/sinatra_simple')
+
+describe Sinatra do
+  before do
+    clear_all_traces 
+  end
+
+  it "should trace a request to a simple sinatra stack" do
+    @app = SinatraSimple
+    
+    r = get "/render"
+    
+    traces = get_all_traces
+    traces.count.must_equal 9
+
+    validate_outer_layers(traces, 'rack')
+
+    traces[1]['Layer'].must_equal "sinatra"
+    traces[3]['Label'].must_equal "profile_entry"
+    traces[6]['Controller'].must_equal "SinatraSimple"
+    traces[7]['Label'].must_equal "info"
+  end
+end
+

data/test/minitest_helper.rb

@@ -3,6 +3,10 @@ require "minitest/reporters"
 
 ENV["RACK_ENV"] = "test"
 
+# FIXME: Temp hack to fix padrino-core calling RUBY_ENGINE when it's 
+# not defined under Ruby 1.8.7 and 1.9.3
+RUBY_ENGINE = "ruby" unless defined?(RUBY_ENGINE)
+
 unless RUBY_VERSION =~ /^1.8/
   MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
 end
@@ -10,11 +14,11 @@ end
 require 'rubygems'
 require 'bundler'
 
-Bundler.require(:default, :test)
-
 # Preload memcache-client
 require 'memcache'
 
+Bundler.require(:default, :test)
+
 @trace_dir = "/tmp/"
 $trace_file = @trace_dir + "trace_output.bson"
 
@@ -110,3 +114,30 @@ def layer_doesnt_have_key(traces, layer, key)
   has_key.must_equal false
 end
 
+##
+# Sinatra and Padrino Related Helpers
+# 
+# Taken from padrino-core gem
+#
+
+class Sinatra::Base
+  # Allow assertions in request context
+  include MiniTest::Assertions
+end
+
+
+class MiniTest::Spec
+  include Rack::Test::Methods
+
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Padrino::Application, &block)
+    @app = Sinatra.new(base, &block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oboe
 version: !ruby/object:Gem::Version
-  version: 2.5.0.7
+  version: 2.6.0.2
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-13 00:00:00.000000000 Z
+date: 2014-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -85,6 +85,8 @@ files:
 - lib/oboe/api/tracing.rb
 - lib/oboe/api/util.rb
 - lib/oboe/config.rb
+- lib/oboe/frameworks/padrino.rb
+- lib/oboe/frameworks/padrino/templates.rb
 - lib/oboe/frameworks/rails.rb
 - lib/oboe/frameworks/rails/helpers/rum/rum_ajax_header.js.erb
 - lib/oboe/frameworks/rails/helpers/rum/rum_footer.js.erb
@@ -99,6 +101,8 @@ files:
 - lib/oboe/frameworks/rails/inst/connection_adapters/oracle.rb
 - lib/oboe/frameworks/rails/inst/connection_adapters/postgresql.rb
 - lib/oboe/frameworks/rails/inst/connection_adapters/utils.rb
+- lib/oboe/frameworks/sinatra.rb
+- lib/oboe/frameworks/sinatra/templates.rb
 - lib/oboe/inst/cassandra.rb
 - lib/oboe/inst/dalli.rb
 - lib/oboe/inst/http.rb
@@ -121,6 +125,10 @@ files:
 - lib/rails/generators/oboe/templates/oboe_initializer.rb
 - oboe.gemspec
 - release.sh
+- test/frameworks/apps/padrino_simple.rb
+- test/frameworks/apps/sinatra_simple.rb
+- test/frameworks/padrino_test.rb
+- test/frameworks/sinatra_test.rb
 - test/instrumentation/cassandra_test.rb
 - test/instrumentation/dalli_test.rb
 - test/instrumentation/http_test.rb
@@ -142,8 +150,6 @@ files:
 - test/support/config_test.rb
 - test/support/srv1_localset_test.rb
 - test/support/xtrace_test.rb
-- test/frameworks/apps/padrino_simple.rb
-- test/frameworks/test_padrino.rb
 homepage: http://www.appneta.com/products/traceview/
 licenses:
 - AppNeta Open License, Version 1.0
@@ -169,8 +175,10 @@ signing_key:
 specification_version: 4
 summary: AppNeta TraceView performance instrumentation gem for Ruby
 test_files:
+- test/frameworks/padrino_test.rb
+- test/frameworks/sinatra_test.rb
+- test/frameworks/apps/sinatra_simple.rb
 - test/frameworks/apps/padrino_simple.rb
-- test/frameworks/test_padrino.rb
 - test/minitest_helper.rb
 - test/instrumentation/mongo_test.rb
 - test/instrumentation/redis_hashes_test.rb

data/test/frameworks/test_padrino.rb

@@ -1,32 +0,0 @@
-require "minitest_helper"
-
-describe Padrino do
-  before do
-    clear_all_traces 
-  end
-
-  it "should do this" do
-
-    mock_app do
-      get("/") { render :erb, "ok" }
-    end
-    debugger
-    r = get "/"
-    
-    traces = get_all_traces
-    traces.count.must_equal 5
-
-    validate_outer_layers(traces, 'dalli_test')
-
-    traces[1].has_key?("KVOp").must_equal true
-    traces[1].has_key?("KVKey").must_equal true
-    traces[1]['Layer'].must_equal "memcache"
-    traces[1]['KVKey'].must_equal "some_key"
-
-    traces[2]['Layer'].must_equal "memcache"
-    traces[2]['Label'].must_equal "info"
-    traces[2].has_key?('KVHit')
-
-  end
-end
-