oboe 1.3.0

data/lib/oboe/frameworks/rails/inst/memcache.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+
+if defined?(::MemCache)
+  class ::MemCache
+    include Oboe::API::Memcache
+
+    MEMCACHE_OPS.reject { |m| not method_defined?(m) }.each do |m|
+      opts = { :KVOp => m }
+      define_method("#{m}_with_oboe") do |*args|
+        Oboe::API.trace('memcache', opts) do
+          send("#{m}_without_oboe", *args) 
+        end
+      end
+
+      class_eval "alias #{m}_without_oboe #{m}"
+      class_eval "alias #{m} #{m}_with_oboe"
+    end
+
+    define_method(:request_setup_with_oboe) do |*args|
+      server, cache_key = request_setup_without_oboe(*args)
+      Oboe::API.log('memcache', 'info', { :KVKey => cache_key, :RemoteHost => server.host })
+      return [server, cache_key]
+    end
+
+    alias request_setup_without_oboe request_setup
+    alias request_setup request_setup_with_oboe
+
+
+    define_method(:cache_get_with_oboe) do |server, cache_key|
+      result = cache_get_without_oboe(server, cache_key)
+      Oboe::API.log('memcache', 'info', { :KVHit => memcache_hit?(result) })
+      result
+    end
+
+    alias cache_get_without_oboe cache_get
+    alias cache_get cache_get_with_oboe
+  end
+  puts "[oboe/loading] Instrumenting memcache" if Oboe::Config[:verbose]
+end

data/lib/oboe/frameworks/rails/inst/memcached.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+#
+
+if defined?(Memcached)
+  class Memcached
+    include Oboe::API::Memcache
+
+    MEMCACHE_OPS.reject { |m| not method_defined?(m) }.each do |m|
+      define_method("#{m}_with_oboe") do |*args|
+        opts = { :KVOp => m }
+        if args.length and args[0].class != Array
+            opts[:KVKey] = args[0].to_s
+            rhost = remote_host(args[0].to_s)
+            opts[:RemoteHost] = rhost if rhost
+        end
+
+        Oboe::API.trace('memcache', opts) do
+          result = send("#{m}_without_oboe", *args)
+          if m == :get and args.length and args[0].class == String
+              Oboe::API.log('memcache', 'info', { :KVHit => memcache_hit?(result) })
+          end
+          result
+        end
+      end
+
+      class_eval "alias #{m}_without_oboe #{m}"
+      class_eval "alias #{m} #{m}_with_oboe"
+    end
+  end
+  puts "[oboe/loading] Instrumenting memcached" if Oboe::Config[:verbose]
+end

data/lib/oboe/frameworks/rails/inst/rack.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+
+module Oboe
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      header = env['HTTP_X_TRACE']
+      result, header = Oboe::API.start_trace('rack', header) do
+        env['HTTP_X_TRACE'] = Oboe::Context.toString()
+        @app.call(env)
+      end
+      result
+    rescue Exception => e
+      header = e.instance_variable_get(:@xtrace)
+      raise
+    ensure
+      env['HTTP_X_TRACE'] = header if header
+    end
+  end
+end
+
+if false and defined?(::Rails.configuration.middleware)
+  puts "[oboe/loading] Instrumenting rack" if Oboe::Config[:verbose]
+  ::Rails.configuration.middleware.insert 0, Oboe::Middleware
+end

data/lib/oboe/frameworks/rails/rails.rb

@@ -0,0 +1,55 @@
+
+module Oboe
+  module Inst
+    module Rails
+      def self.load_initializer
+        # Force load the tracelytics Rails initializer if there is one
+        # Prefer oboe.rb but give priority to tracelytics.rb if it exists
+        if ::Rails::VERSION::MAJOR > 2
+          rails_root = "#{::Rails.root.to_s}"
+        else
+          rails_root = "#{RAILS_ROOT}"
+        end
+
+        if File.exists?("#{rails_root}/config/initializers/tracelytics.rb")
+          tr_initializer = "#{rails_root}/config/initializers/tracelytics.rb"
+        else 
+          tr_initializer = "#{rails_root}/config/initializers/oboe.rb"
+        end
+        require tr_initializer if File.exists?(tr_initializer)
+      end
+
+      def self.load_instrumentation
+        pattern = File.join(File.dirname(__FILE__), 'inst', '*.rb')
+        Dir.glob(pattern) do |f|
+          begin
+            require f
+          rescue => e
+            $stderr.puts "[oboe/loading] Error loading rails insrumentation file '#{f}' : #{e}"
+          end
+        end
+        if ::Rails::VERSION::MAJOR > 2
+          puts "Tracelytics oboe gem #{Gem.loaded_specs['oboe'].version.to_s} successfully loaded."
+        else
+          puts "Tracelytics oboe gem #{Oboe::Version::STRING} successfully loaded." 
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Rails)
+  if ::Rails::VERSION::MAJOR > 2
+    module Oboe
+      class Railtie < ::Rails::Railtie
+        config.after_initialize do
+          Oboe::Inst::Rails.load_instrumentation
+        end
+      end
+    end
+  else
+    Oboe::Inst::Rails.load_initializer
+    Oboe::Inst::Rails.load_instrumentation
+  end
+end
+

data/lib/oboe/loading.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+
+module Oboe
+  module Loading
+
+    def self.require_api
+      require 'oboe/version'
+
+      pattern = File.join(File.dirname(__FILE__), 'api', '*.rb')
+      Dir.glob(pattern) do |f|
+        require f
+      end
+      require 'oboe/api'
+
+      begin
+        Oboe::API.extend_with_tracing
+      rescue LoadError => e
+        Oboe::API.extend_with_noop
+      end
+      
+      require 'oboe/config'
+    end
+
+    def self.load_framework_instrumentation
+      pattern = File.join(File.dirname(__FILE__), 'frameworks/*/', '*.rb')
+      Dir.glob(pattern) do |f|
+        begin
+          require f
+        rescue => e
+          $stderr.puts "[oboe/loading] Error loading framework file '#{f}' : #{e}"
+        end
+      end
+    end
+  end
+end
+
+Oboe::Loading.require_api
+Oboe::Loading.load_framework_instrumentation
+

data/lib/oboe/version.rb

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

data/lib/oboe_fu.rb

@@ -0,0 +1,4 @@
+
+puts "[oboe_fu] This gem has been deprecated.  Please use the 'oboe' gem instead."
+require 'oboe'
+

data/lib/oboe_metal.rb

@@ -0,0 +1,151 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+
+module Oboe_metal
+  class Context
+    def self.log(layer, label, options = {})
+      evt = Oboe::Context.createEvent()
+      evt.addInfo("Layer", layer.to_s)
+      evt.addInfo("Label", label.to_s)
+
+      options.each_pair do |k, v|
+        evt.addInfo(k.to_s, v.to_s)
+      end
+
+      evt.addInfo("Backtrace", Kernel.caller.join("\r\n"))
+
+      Oboe.reporter.sendReport(evt)
+    end
+  end
+end
+
+
+module OboeMethodProfiling
+    def self.included klass
+        klass.extend ClassMethods
+    end
+
+    module ClassMethods
+        def profile_method(method_name, profile_name, store_args=false, store_return=false, profile=false)
+            #this only gets file and line where profiling is turned on, presumably
+            #right after the function definition. ruby 1.9 has nice introspection (Method.source_location)
+            #but its appears no such luck for ruby 1.8
+            version = RbConfig::CONFIG['ruby_version']
+            file = nil
+            line = nil
+            if version and version.match(/^1.9/)
+                info = self.method(method_name).source_location
+                if !info.nil?
+                  file = info[0]
+                  line = info[1] 
+                end
+            else
+                info = Kernel.caller[0].split(':')
+                file = info.first
+                line = info.last
+            end
+
+            #profiling via ruby-prof, is it possible to get return value of profiled code?
+            code = "def _oboe_profiled_#{method_name}(*args, &block)
+                        def pps(*args)
+                            old_out = $stdout
+                            begin
+                                s = StringIO.new
+                                $stdout = s
+                                pp(*args)
+                            ensure
+                                $stdout = old_out
+                            end
+                            s.string
+                        end
+
+                        # file and line number are fetched in Context.log
+                        # because we have access to the correct backtrace there
+                        entry_kvs = {'Language'     => 'ruby',
+                                     'ProfileName'  => '#{profile_name}',
+                                     'FunctionName' => '#{method_name}',
+                                     'Class'        => self.class.to_s.rpartition('::').last,
+                                     'Module'       => self.class.to_s.rpartition('::').first,
+                                     'File'         => '#{file}',
+                                     'LineNumber'    => '#{line}' 
+                                    }
+
+                        if #{store_args}
+                            entry_kvs['Args'] = pps *args
+                        end
+
+                        Oboe::Context.log(nil, 'profile_entry', entry_kvs)
+
+                        ret = _oboe_orig_#{method_name}(*args, &block)
+
+                        exit_kvs =  {'Language'     => 'ruby',
+                                     'ProfileName'  => '#{profile_name}'
+                                    }
+                        
+                        if #{store_return}
+                            exit_kvs['ReturnValue'] = pps ret
+                        end
+
+                        Oboe::Context.log(nil, 'profile_exit', exit_kvs)
+
+                        ret
+                    end"
+            class_eval code, __FILE__, __LINE__
+            alias_method "_oboe_orig_#{method_name}", method_name
+            alias_method method_name, "_oboe_profiled_#{method_name}"
+        end
+    end
+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])
+    end
+
+    return @reporter
+  end
+end
+
+Oboe_metal::Context.init()

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: oboe
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 1
+  - 3
+  - 0
+  version: 1.3.0
+platform: ruby
+authors: 
+- Tracelytics, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-12 00:00:00 Z
+dependencies: []
+
+description: The oboe gem provides Tracelytics instrumentation for Ruby and Ruby frameworkes.
+email: contact@tracelytics.com
+executables: []
+
+extensions: 
+- ext/oboe_metal/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+files: 
+- lib/oboe_metal.rb
+- lib/oboe.rb
+- lib/oboe/loading.rb
+- lib/oboe/api.rb
+- lib/oboe/api/memcache.rb
+- lib/oboe/api/layerinit.rb
+- lib/oboe/api/util.rb
+- lib/oboe/api/logging.rb
+- lib/oboe/api/tracing.rb
+- lib/oboe/version.rb
+- lib/oboe/config.rb
+- lib/oboe/frameworks/rails/inst/memcache.rb
+- lib/oboe/frameworks/rails/inst/http.rb
+- lib/oboe/frameworks/rails/inst/rack.rb
+- lib/oboe/frameworks/rails/inst/action_controller.rb
+- lib/oboe/frameworks/rails/inst/dalli.rb
+- lib/oboe/frameworks/rails/inst/active_record.rb
+- lib/oboe/frameworks/rails/inst/memcached.rb
+- lib/oboe/frameworks/rails/rails.rb
+- lib/oboe_fu.rb
+- ext/oboe_metal/noop/noop.c
+- ext/oboe_metal/src/oboe_wrap.cxx
+- ext/oboe_metal/src/oboe.hpp
+- install.rb
+- init.rb
+- LICENSE
+- ext/oboe_metal/extconf.rb
+homepage: http://tracelytics.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tracelytics instrumentation gem
+test_files: []
+