oboe 1.3.9.1 → 1.4.0.2

data/lib/oboe/inst/resque.rb

@@ -0,0 +1,192 @@
+# Copyright (c) 2013 by Tracelytics, Inc.
+# All rights reserved.
+
+require 'socket'
+
+module Oboe
+  module Inst
+    module Resque
+
+      def self.included(base)
+        base.send :extend, ::Resque
+      end
+
+      def extract_trace_details(op, klass, args)
+        report_kvs = {}
+
+        begin
+          report_kvs[:Op] = op.to_s
+          report_kvs[:Class] = klass.to_s if klass
+
+          if Oboe::Config[:resque][:log_args]
+            kv_args = args.to_json
+            
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+          
+          report_kvs[:Backtrace] = Oboe::API.backtrace
+        rescue
+        end
+
+        report_kvs
+      end
+
+      def enqueue_with_oboe(klass, *args)
+        if Oboe.tracing?
+          report_kvs = extract_trace_details(:enqueue, klass, args)
+
+          Oboe::API.trace('resque', report_kvs, :enqueue) do
+            args.push({:parent_trace_id => Oboe::Context.toString}) if Oboe::Config[:resque][:link_workers]
+            enqueue_without_oboe(klass, *args)
+          end
+        else
+          enqueue_without_oboe(klass, *args)
+        end
+      end
+
+      def enqueue_to_with_oboe(queue, klass, *args)
+        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:enqueue)
+          report_kvs = extract_trace_details(:enqueue_to, klass, args)
+          report_kvs[:Queue] = queue.to_s if queue
+
+          Oboe::API.trace('resque', report_kvs) do
+            args.push({:parent_trace_id => Oboe::Context.toString}) if Oboe::Config[:resque][:link_workers]
+            enqueue_to_without_oboe(queue, klass, *args)
+          end
+        else
+          enqueue_to_without_oboe(queue, klass, *args)
+        end
+      end
+
+      def dequeue_with_oboe(klass, *args)
+        if Oboe.tracing?
+          report_kvs = extract_trace_details(:dequeue, klass, args)
+
+          Oboe::API.trace('resque', report_kvs) do
+            dequeue_without_oboe(klass, *args)
+          end
+        else
+          dequeue_without_oboe(klass, *args)
+        end
+      end
+    end
+
+    module ResqueWorker
+      def perform_with_oboe(job)
+        report_kvs = {}
+        last_arg = nil
+
+        begin
+          report_kvs[:Op] = :perform
+
+          # Set these keys for the ability to separate out
+          # background tasks into a separate app on the server-side UI
+          report_kvs[:Controller] = :Resque
+          report_kvs[:Action] = :perform
+
+          report_kvs['HTTP-Host'] = Socket.gethostname
+          report_kvs[:URL] = '/resque/' + job.queue
+          report_kvs[:Method] = 'NONE'
+          report_kvs[:Queue] = job.queue
+            
+          report_kvs[:Class] = job.payload['class']
+
+          if Oboe::Config[:resque][:log_args]
+            kv_args = job.payload['args'].to_json
+            
+            # Limit the argument json string to 1024 bytes
+            if kv_args.length > 1024
+              report_kvs[:Args] = kv_args[0..1023] + '...[snipped]'
+            else
+              report_kvs[:Args] = kv_args
+            end
+          end
+
+          last_arg = job.payload['args'].last
+        rescue
+        end
+
+        if last_arg.is_a?(Hash) and last_arg.has_key?('parent_trace_id')
+          begin
+            # Since the enqueue was traced, we force trace the actual job execution and reference
+            # the enqueue trace with ParentTraceID
+            report_kvs[:ParentTraceID] = last_arg['parent_trace_id']
+            job.payload['args'].pop
+
+          rescue
+          end
+
+          Oboe::API.force_trace do
+            Oboe::API.start_trace('resque', nil, report_kvs) do
+              perform_without_oboe(job)
+            end
+          end
+
+        else
+          Oboe::API.start_trace('resque', nil, report_kvs) do
+            perform_without_oboe(job)
+          end
+        end
+      end
+    end
+
+    module ResqueJob
+      def fail_with_oboe(exception)
+        if Oboe.tracing?
+          Oboe::API.log_exception('resque', exception)
+        end
+        fail_without_oboe(exception)
+      end
+    end
+  end
+end
+
+if defined?(::Resque)
+  puts "[oboe/loading] Instrumenting resque" if Oboe::Config[:verbose]
+
+  ::Resque.module_eval do
+    include Oboe::Inst::Resque
+
+    [ :enqueue, :enqueue_to, :dequeue ].each do |m|
+      if method_defined?(m)
+        module_eval "alias #{m}_without_oboe #{m}"
+        module_eval "alias #{m} #{m}_with_oboe"
+      elsif Oboe::Config[:verbose]
+        puts "[oboe/loading] Couldn't properly instrument Resque (#{m}).  Partial traces may occur."
+      end
+    end
+  end
+
+  if defined?(::Resque::Worker)
+    ::Resque::Worker.class_eval do
+      include Oboe::Inst::ResqueWorker
+
+      if method_defined?(:perform)
+        alias perform_without_oboe perform
+        alias perform perform_with_oboe
+      elsif Oboe::Config[:verbose]
+        puts "[oboe/loading] Couldn't properly instrument ResqueWorker (perform).  Partial traces may occur."
+      end
+    end
+  end
+
+  if defined?(::Resque::Job)
+    ::Resque::Job.class_eval do
+      include Oboe::Inst::ResqueJob
+
+      if method_defined?(:fail)
+        alias fail_without_oboe fail
+        alias fail fail_with_oboe
+      elsif Oboe::Config[:verbose]
+        puts "[oboe/loading] Couldn't properly instrument ResqueWorker (fail).  Partial traces may occur."
+      end
+    end
+  end
+end
+
+

data/lib/oboe/loading.rb

@@ -26,7 +26,7 @@ module Oboe
   module Loading
 
     def self.load_access_key
-      unless Oboe::Config.has_key?(:access_key)  
+      unless Oboe::Config.access_key
         config_file = '/etc/tracelytics.conf'
         return unless File.exists?(config_file)
         

data/lib/oboe/version.rb

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

data/lib/oboe_metal.rb

@@ -50,45 +50,6 @@ end
 module Oboe
   include Oboe_metal
 
-  # TODO: Ensure that the :tracing_mode is set to "always", "through", or "never"
-  Config = {
-    :tracing_mode => "through",
-    :reporter_host => "127.0.0.1",
-    :sample_rate => 1000000
-  }
-
-  def self.passthrough?
-    ["always", "through"].include?(Oboe::Config[:tracing_mode])
-  end
-
-  def self.always?
-    Oboe::Config[:tracing_mode] == "always"
-  end
-
-  def self.through?
-    Oboe::Config[:tracing_mode] == "through"
-  end
-
-  def self.never?
-    Oboe::Config[:tracing_mode] == "never"
-  end
-
-  def self.now?
-    Oboe::Context.isValid and not Oboe.never?
-  end
-
-  def self.start?
-    not Oboe::Context.isValid and Oboe.always?
-  end
-
-  def self.continue?
-    Oboe::Context.isValid and not Oboe.never?
-  end
-
-  def self.log(layer, label, options = {})
-    Context.log(layer, label, options = options)
-  end
-
   def self.reporter
     if !@reporter
       @reporter = Oboe::UdpReporter.new(Oboe::Config[:reporter_host])

data/lib/rails/generators/oboe/templates/oboe_initializer.rb

@@ -13,4 +13,36 @@ if defined?(::Oboe::Config)
 <% end %>
   # Verbose output of instrumentation initialization
   # Oboe::Config[:verbose] = <%= @verbose %>
+
+  #
+  # Resque Options
+  #
+  # :link_workers - associates Resque enqueue operations with the jobs they queue by piggybacking
+  #                 an additional argument on the Redis queue that is stripped prior to job 
+  #                 processing 
+  #                 !!! Note: Make sure both the enqueue side and the Resque workers are instrumented
+  #                 before enabling this or jobs will fail !!!
+  #                 (Default: false)
+  # Oboe::Config[:resque][:link_workers] = false
+  #
+  # Set to true to disable Resque argument logging (Default: false)
+  # Oboe::Config[:resque][:log_args] = false
+ 
+  #
+  # Enabling/Disabling Instrumentation
+  #
+  # If you're having trouble with one of the instrumentation libraries, they
+  # can be individually disabled here by setting the :enabled
+  # value to false:
+  #
+  # Oboe::Config[:action_controller][:enabled] = true
+  # Oboe::Config[:active_record][:enabled] = true
+  # Oboe::Config[:action_view][:enabled] = true
+  # Oboe::Config[:cassandra][:enabled] = true
+  # Oboe::Config[:dalli][:enabled] = true
+  # Oboe::Config[:memcache][:enabled] = true
+  # Oboe::Config[:memcached][:enabled] = true
+  # Oboe::Config[:mongo][:enabled] = true
+  # Oboe::Config[:moped][:enabled] = true
+  # Oboe::Config[:resque][:enabled] = true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: oboe
 version: !ruby/object:Gem::Version 
-  hash: 97
+  hash: 123
   prerelease: 
   segments: 
   - 1
-  - 3
-  - 9
-  - 1
-  version: 1.3.9.1
+  - 4
+  - 0
+  - 2
+  version: 1.4.0.2
 platform: ruby
 authors: 
 - Tracelytics, Inc.
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-29 00:00:00 Z
+date: 2013-03-08 00:00:00 Z
 dependencies: []
 
 description: The oboe gem provides AppNeta instrumentation for Ruby and Ruby frameworks.
@@ -40,6 +40,7 @@ files:
 - lib/oboe/ruby.rb
 - lib/oboe/inst/cassandra.rb
 - lib/oboe/inst/dalli.rb
+- lib/oboe/inst/resque.rb
 - lib/oboe/inst/rack.rb
 - lib/oboe/inst/mongo.rb
 - lib/oboe/inst/memcached.rb