oboe 2.7.0.3-java

data/lib/oboe.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+begin
+  require 'oboe/version'
+  require 'oboe/logger'
+  require 'oboe/util'
+  require 'oboe/xtrace'
+
+  # If Oboe_metal is already defined then we are in a PaaS environment
+  # with an alternate metal (such as Heroku: see the oboe-heroku gem)
+  unless defined?(Oboe_metal)
+    begin
+      if RUBY_PLATFORM == 'java'
+        require '/usr/local/tracelytics/tracelyticsagent.jar'
+        require 'joboe_metal'
+      else
+        require 'oboe_metal.so'
+        require 'oboe_metal'
+      end
+    rescue LoadError
+      Oboe.loaded = false
+
+      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"
+        $stderr.puts "=============================================================="
+      end
+    end
+  end
+
+  require 'oboe/config'
+  require 'oboe/loading'
+  require 'method_profiling'
+  require 'oboe/instrumentation'
+  require 'oboe/ruby'
+
+  # Frameworks
+  if Oboe.loaded
+    require 'oboe/frameworks/rails'   if defined?(::Rails)
+    require 'oboe/frameworks/sinatra' if defined?(::Sinatra)
+    require 'oboe/frameworks/padrino' if defined?(::Padrino)
+    require 'oboe/frameworks/grape'   if defined?(::Grape)
+  end
+rescue Exception => e
+  $stderr.puts "[oboe/error] Problem loading: #{e.inspect}"
+  $stderr.puts e.backtrace
+end
+

data/lib/oboe/api.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    def self.extend_with_tracing
+      extend Oboe::API::Logging
+      extend Oboe::API::Tracing
+      extend Oboe::API::Profiling
+      extend Oboe::API::LayerInit
+    end
+    extend Oboe::API::Util
+  end
+end

data/lib/oboe/api/layerinit.rb

@@ -0,0 +1,99 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    module LayerInit
+      # Internal: Report that instrumentation for the given layer has been
+      # installed, as well as the version of instrumentation and version of
+      # layer.
+      #
+      def report_init(layer = 'rack')
+        # Don't send __Init in development or test
+        return if ["development", "test"].include? ENV['RACK_ENV']
+
+        # Don't send __Init if the c-extension hasn't loaded
+        return unless Oboe.loaded
+
+        platform_info = { '__Init' => 1 }
+
+        begin
+          platform_info['Force']                   = true
+          platform_info['Ruby.Platform.Version']   = RUBY_PLATFORM
+          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)
+
+          # Report the framework in use
+          platform_info['Ruby.Rails.Version'] = "Rails-#{::Rails.version}"  if defined?(::Rails)
+          platform_info['Ruby.Grape.Version'] = "Grape-#{::Grape::VERSION}" if defined?(::Grape)
+          platform_info['Ruby.Cramp.Version'] = "Cramp-#{::Cramp::VERSION}" if defined?(::Cramp)
+
+          if defined?(::Padrino)
+            platform_info['Ruby.Padrino.Version'] = "Padrino-#{::Padrino::VERSION}"
+          elsif defined?(::Sinatra)
+            platform_info['Ruby.Sinatra.Version'] = "Sinatra-#{::Sinatra::VERSION}"
+          end
+
+          # Report the instrumented libraries
+          platform_info['Ruby.Cassandra.Version'] = "Cassandra-#{::Cassandra.VERSION}" if defined?(::Cassandra)
+          platform_info['Ruby.Dalli.Version']     = "Dalli-#{::Dalli::VERSION}"        if defined?(::Dalli)
+          platform_info['Ruby.MemCache.Version']  = "MemCache-#{::MemCache::VERSION}"  if defined?(::MemCache)
+          platform_info['Ruby.Moped.Version']     = "Moped-#{::Moped::VERSION}"        if defined?(::Moped)
+          platform_info['Ruby.Redis.Version']     = "Redis-#{::Redis::VERSION}"        if defined?(::Redis)
+          platform_info['Ruby.Resque.Version']    = "Resque-#{::Resque::VERSION}"      if defined?(::Resque)
+
+          # Special case since the Mongo 1.x driver doesn't embed the version number in the gem directly
+          if ::Gem.loaded_specs.has_key?('mongo')
+            platform_info['Ruby.Mongo.Version']     = "Mongo-#{::Gem.loaded_specs['mongo'].version.to_s}"
+          end
+
+          # Report the server in use (if possible)
+          if defined?(::Unicorn)
+            platform_info['Ruby.AppContainer.Version'] = "Unicorn-#{::Unicorn::Const::UNICORN_VERSION}"
+          elsif defined?(::Puma)
+            platform_info['Ruby.AppContainer.Version'] = "Puma-#{::Puma::Const::PUMA_VERSION} (#{::Puma::Const::CODE_NAME})"
+          elsif defined?(::PhusionPassenger)
+            platform_info['Ruby.AppContainer.Version'] = "#{::PhusionPassenger::PACKAGE_NAME}-#{::PhusionPassenger::VERSION_STRING}"
+          elsif defined?(::Thin)
+            platform_info['Ruby.AppContainer.Version'] = "Thin-#{::Thin::VERSION::STRING} (#{::Thin::VERSION::CODENAME})"
+          elsif defined?(::Mongrel)
+            platform_info['Ruby.AppContainer.Version'] = "Mongrel-#{::Mongrel::Const::MONGREL_VERSION}"
+          elsif defined?(::Mongrel2)
+            platform_info['Ruby.AppContainer.Version'] = "Mongrel2-#{::Mongrel2::VERSION}"
+          elsif defined?(::Trinidad)
+            platform_info['Ruby.AppContainer.Version'] = "Trinidad-#{::Trinidad::VERSION}"
+          elsif defined?(::WEBrick)
+            platform_info['Ruby.AppContainer.Version'] = "WEBrick-#{::WEBrick::VERSION}"
+          else
+            platform_info['Ruby.AppContainer.Version'] = File.basename($0)
+          end
+
+        rescue StandardError, ScriptError => e
+          # Also rescue ScriptError (aka SyntaxError) in case one of the expected
+          # version defines don't exist
+
+          platform_info['Error'] = "Error in layerinit: #{e.message}"
+
+          Oboe.logger.debug "Error in layerinit: #{e.message}"
+          Oboe.logger.debug e.backtrace
+        end
+
+        start_trace(layer, nil, platform_info.merge('Force' => true)) { }
+      end
+
+      ##
+      # force_trace has been deprecated and will be removed in a subsequent version.
+      #
+      def force_trace
+        Oboe.logger.warn "Oboe::API::LayerInit.force_trace has been deprecated and will be removed in a subsequent version."
+
+        saved_mode = Oboe::Config[:tracing_mode]
+        Oboe::Config[:tracing_mode] = 'always'
+        yield
+      ensure
+        Oboe::Config[:tracing_mode] = saved_mode
+      end
+    end
+  end
+end

data/lib/oboe/api/logging.rb

@@ -0,0 +1,129 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    module Logging
+
+      # Public: Report an event in an active trace.
+      #
+      # layer - The layer the reported event belongs to
+      # label - The label for the reported event. See API documentation for
+      #         reserved labels and usage.
+      # opts - A hash containing key/value pairs that will be reported along
+      #        with this event (optional).
+      #
+      # Example
+      #
+      #   log('logical_layer', 'entry')
+      #   log('logical_layer', 'info', { :list_length => 20 })
+      #   log('logical_layer', 'exit')
+      #
+      # Returns nothing.
+      def log(layer, label, opts={})
+        log_event(layer, label, Oboe::Context.createEvent, opts)
+      end
+
+      # Public: Report an exception.
+      #
+      # layer - The layer the reported event belongs to
+      # exn - The exception to report
+      #
+      # Example
+      #
+      #   begin
+      #     function_without_oboe()
+      #   rescue Exception => e
+      #     log_exception('rails', e)
+      #     raise
+      #   end
+      #
+      # Returns nothing.
+      def log_exception(layer, exn)
+        unless exn.instance_variable_get(:@oboe_logged)
+          log(layer, 'error', {
+            :ErrorClass => exn.class.name,
+            :Message => exn.message,
+            :Backtrace => exn.backtrace.join("\r\n")
+          })
+          exn.instance_variable_set(:@oboe_logged, true)
+        end
+      end
+
+      # Public: Decide whether or not to start a trace, and report an event
+      # appropriately.
+      #
+      # layer - The layer the reported event belongs to
+      # xtrace - An xtrace metadata string, or nil.
+      # opts - A hash containing key/value pairs that will be reported along
+      #        with this event (optional).
+      #
+      # Returns nothing.
+      def log_start(layer, xtrace, opts={})
+        return if Oboe.never? or (opts.has_key?(:URL) and ::Oboe::Util.static_asset?(opts[:URL]))
+
+        if xtrace and not xtrace.to_s.empty?
+          Oboe::Context.fromString(xtrace)
+        end
+
+        if Oboe.tracing?
+          log_entry(layer, opts)
+        elsif opts.has_key?('Force') or Oboe.sample?(opts.merge(:layer => layer, :xtrace => xtrace))
+          log_event(layer, 'entry', Oboe::Context.startTrace, opts)
+        end
+      end
+
+      # Public: Report an exit event.
+      #
+      # layer - The layer the reported event belongs to
+      #
+      # Returns an xtrace metadata string
+      def log_end(layer, opts={})
+        log_event(layer, 'exit', Oboe::Context.createEvent, opts)
+        xtrace = Oboe::Context.toString
+        Oboe::Context.clear
+        xtrace
+      end
+
+      def log_entry(layer, opts={}, protect_op=nil)
+        Oboe.layer_op = protect_op if protect_op
+        log_event(layer, 'entry', Oboe::Context.createEvent, opts)
+      end
+
+      def log_exit(layer, opts={}, protect_op=nil)
+        Oboe.layer_op = nil if protect_op
+        log_event(layer, 'exit', Oboe::Context.createEvent, opts)
+      end
+
+      # Internal: Report an event.
+      #
+      # layer - The layer the reported event belongs to
+      # label - The label for the reported event. See API documentation for
+      #         reserved labels and usage.
+      # opts - A hash containing key/value pairs that will be reported along
+      #        with this event (optional).
+      #
+      # Examples
+      #
+      #   entry = Oboe::Context.createEvent
+      #   log_event('rails', 'entry', exit, { :controller => 'user', :action => 'index' })
+      #   exit = Oboe::Context.createEvent
+      #   exit.addEdge(entry.getMetadata)
+      #   log_event('rails', 'exit', exit)
+      #
+      # Returns nothing.
+      def log_event(layer, label, event, opts={})
+        if layer
+            event.addInfo('Layer', layer.to_s)
+        end
+        event.addInfo('Label', label.to_s)
+
+        opts.each do |k, v|
+          event.addInfo(k.to_s, v.to_s) if valid_key? k
+        end if !opts.nil? and opts.any?
+
+        Oboe::Reporter.sendReport(event) if Oboe.loaded
+      end
+    end
+  end
+end

data/lib/oboe/api/memcache.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    module Memcache
+      MEMCACHE_OPS = %w{add append cas decr decrement delete fetch get incr increment prepend replace set}
+
+      def memcache_hit?(result)
+        result.nil? ? 0 : 1
+      end
+
+      def remote_host(key)
+        return unless defined?(Lib.memcached_server_by_key)\
+          and defined?(@struct) and defined?(is_unix_socket?)
+
+        server_as_array = Lib.memcached_server_by_key(@struct, args[0].to_s)
+        if server_as_array.is_a?(Array)
+          server = server_as_array.first
+          if is_unix_socket?(server)
+            return "localhost"
+          elsif defined?(server.hostname)
+            return server.hostname
+          end
+        end
+      end
+    end
+  end
+end

data/lib/oboe/api/profiling.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    module Profiling
+
+      ##
+      # Public: Profile a given block of code. Detect any exceptions thrown by
+      # the block and report errors.
+      #
+      # profile_name - A name used to identify the block being profiled.
+      # report_kvs - A hash containing key/value pairs that will be reported along
+      #              with the event of this profile (optional).
+      # with_backtrace - Boolean to indicate whether a backtrace should
+      #                  be collected with this trace event.
+      #
+      # Example
+      #
+      #   def computation(n)
+      #     Oboe::API.profile('fib', { :n => n }) do
+      #       fib(n)
+      #     end
+      #   end
+      #
+      # Returns the result of the block.
+      def profile(profile_name, report_kvs={}, with_backtrace=false)
+
+        report_kvs[:Language] ||= :ruby
+        report_kvs[:ProfileName] ||= profile_name
+        report_kvs[:Backtrace] = Oboe::API.backtrace if with_backtrace
+
+        Oboe::API.log(nil, 'profile_entry', report_kvs)
+
+        begin
+          yield
+        rescue Exception => e
+          log_exception(nil, e)
+          raise
+        ensure
+          exit_kvs = {}
+          exit_kvs[:Language] = :ruby
+          exit_kvs[:ProfileName] = report_kvs[:ProfileName]
+
+          Oboe::API.log(nil, 'profile_exit', exit_kvs)
+        end
+      end
+    end
+  end
+end

data/lib/oboe/api/tracing.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module API
+    module Tracing
+
+      # Public: Trace a given block of code. Detect any exceptions thrown by
+      # the block and report errors.
+      #
+      # layer - The layer the block of code belongs to.
+      # opts - A hash containing key/value pairs that will be reported along
+      # with the first event of this layer (optional).
+      # protect_op - specify the operation being traced.  Used to avoid
+      # double tracing between operations that call each other
+      #
+      # Example
+      #
+      #   def computation(n)
+      #     fib(n)
+      #     raise Exception.new
+      #   end
+      #
+      #   def computation_with_oboe(n)
+      #     trace('fib', { :number => n }) do
+      #       computation(n)
+      #     end
+      #   end
+      #
+      #   result = computation_with_oboe(1000)
+      #
+      # Returns the result of the block.
+      def trace(layer, opts={}, protect_op=nil)
+        log_entry(layer, opts, protect_op)
+        begin
+          yield
+        rescue Exception => e
+          log_exception(layer, e)
+          raise
+        ensure
+          log_exit(layer, {}, protect_op)
+        end
+      end
+
+      # Public: Trace a given block of code which can start a trace depending
+      # on configuration and probability. Detect any exceptions thrown by the
+      # block and report errors.
+      #
+      # When start_trace returns control to the calling context, the oboe
+      # context will be cleared.
+      #
+      # layer - The layer the block of code belongs to.
+      # opts - A hash containing key/value pairs that will be reported along
+      # with the first event of this layer (optional).
+      #
+      # Example
+      #
+      #   def handle_request(request, response)
+      #     # ... code that modifies request and response ...
+      #   end
+      #
+      #   def handle_request_with_oboe(request, response)
+      #     result, xtrace = start_trace('rails', request['X-Trace']) do
+      #       handle_request(request, response)
+      #     end
+      #     result
+      #   rescue Exception => e
+      #     xtrace = e.xtrace
+      #   ensure
+      #     response['X-trace'] = xtrace
+      #   end
+      #
+      # Returns a list of length two, the first element of which is the result
+      # of the block, and the second element of which is the oboe context that
+      # was set when the block completed execution.
+      def start_trace(layer, xtrace=nil, opts={})
+        log_start(layer, xtrace, opts)
+        begin
+          result = yield
+        rescue Exception => e
+          log_exception(layer, e)
+          e.instance_variable_set(:@xtrace, log_end(layer))
+          raise
+        end
+        xtrace = log_end(layer)
+
+        [result, xtrace]
+      end
+
+      # Public: Trace a given block of code which can start a trace depending
+      # on configuration and probability. Detect any exceptions thrown by the
+      # block and report errors. Insert the oboe metadata into the provided for
+      # later user.
+      #
+      # The motivating use case for this is HTTP streaming in rails3. We need
+      # access to the exit event's trace id so we can set the header before any
+      # work is done, and before any headers are sent back to the client.
+      #
+      # layer - The layer the block of code belongs to.
+      # target - The target object in which to place the oboe metadata.
+      # opts - A hash containing key/value pairs that will be reported along
+      # with the first event of this layer (optional).
+      #
+      # Example:
+      #
+      #   def handle_request(request, response)
+      #     # ... code that does something with request and response ...
+      #   end
+      #
+      #   def handle_request_with_oboe(request, response)
+      #     start_trace_with_target('rails', request['X-Trace'], response) do
+      #       handle_request(request, response)
+      #     end
+      #   end
+      #
+      # Returns the result of the block.
+      def start_trace_with_target(layer, xtrace, target, opts={})
+        log_start(layer, xtrace, opts)
+        exit_evt = Oboe::Context.createEvent
+        begin
+          target['X-Trace'] = Oboe::Event.metadataString(exit_evt) if Oboe.tracing?
+          yield
+        rescue Exception => e
+          log_exception(layer, e)
+          raise
+        ensure
+          exit_evt.addEdge(Oboe::Context.get())
+          log_event(layer, 'exit', exit_evt)
+          Oboe::Context.clear
+        end
+      end
+    end
+  end
+end