oboe 2.7.0.3-java

data/lib/oboe/api/util.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'pp'
+
+module Oboe
+  module API
+    module Util
+      BACKTRACE_CUTOFF = 200
+
+      # Internal: Check whether the provided key is reserved or not. Reserved
+      # keys are either keys that are handled by liboboe calls or the oboe gem.
+      #
+      # key - the key to check.
+      #
+      # Return a boolean indicating whether or not key is reserved.
+      def valid_key?(key)
+        !%w[ Label Layer Edge Timestamp Timestamp_u ].include? key.to_s
+      end
+
+      # Internal: Get the current backtrace.
+      #
+      # ignore - Number of frames to ignore at the end of the backtrace. Use
+      #          when you know how many layers deep in oboe the call is being
+      #          made.
+      #
+      # Returns a string with each frame of the backtrace separated by '\r\n'.
+      def backtrace(ignore=1)
+        trim_backtrace(Kernel.caller).join("\r\n")
+      end
+
+      # Internal: Trim a backtrace to a manageable size
+      #
+      # backtrace - the backtrace (an array of stack frames/from Kernel.caller)
+      #
+      # Returns a trimmed backtrace
+      def trim_backtrace(backtrace)
+        return backtrace unless backtrace.is_a?(Array)
+
+        length = backtrace.size
+        if length > BACKTRACE_CUTOFF
+          # Trim backtraces by getting the first 180 and last 20 lines
+          trimmed = backtrace[0, 180] + ['...[snip]...'] + backtrace[length - 20, 20]
+        else
+          trimmed = backtrace
+        end
+        trimmed
+      end
+
+      # Internal: Check if a host is blacklisted from tracing
+      #
+      # addr_port - the addr_port from Net::HTTP although this method
+      # can be used from any component in reality
+      #
+      # Returns a boolean on blacklisted state
+      def blacklisted?(addr_port)
+        return false unless Oboe::Config.blacklist
+
+        # Ensure that the blacklist is an array
+        unless Oboe::Config.blacklist.is_a?(Array)
+          val = Oboe::Config[:blacklist]
+          Oboe::Config[:blacklist] = [ val.to_s ]
+        end
+
+        Oboe::Config.blacklist.each do |h|
+          return true if addr_port.to_s.match(h.to_s)
+        end
+
+        false
+      end
+
+      # Internal: Pretty print a list of arguments for reporting
+      #
+      # args - the list of arguments to work on
+      #
+      # Returns a pretty string representation of arguments
+      def pps(*args)
+        old_out = $stdout
+        begin
+          s = StringIO.new
+          $stdout = s
+          pp(*args)
+        ensure
+          $stdout = old_out
+        end
+        s.string
+      end
+
+      # Internal: Determine a string to report representing klass
+      #
+      # args - an instance of a Class, a Class or a Module
+      #
+      # Returns a string representation of klass
+      def get_class_name(klass)
+        kv = {}
+        if klass.to_s =~ /::/
+          klass.class.to_s.rpartition('::').last
+        else
+          if klass.is_a?(Class) and klass.is_a?(Module)
+            # Class
+            kv["Class"] = klass.to_s
+
+          elsif (not klass.is_a?(Class) and not klass.is_a?(Module))
+            # Class instance
+            kv["Class"] = klass.class.to_s
+
+          else
+            # Module
+            kv["Module"] = klass.to_s
+          end
+        end
+        kv
+      end
+
+    end
+  end
+end

data/lib/oboe/config.rb

@@ -0,0 +1,140 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  ##
+  # This module exposes a nested configuration hash that can be used to
+  # configure and/or modify the functionality of the oboe gem.
+  #
+  # Use Oboe::Config.show to view the entire nested hash.
+  #
+  module Config
+    @@config = {}
+
+    @@instrumentation = [ :cassandra, :dalli, :nethttp, :memcached, :memcache, :mongo,
+                          :moped, :rack, :redis, :resque, :action_controller, :action_view,
+                          :active_record ]
+
+    ##
+    # Return the raw nested hash.
+    #
+    def self.show
+      @@config
+    end
+
+    def self.initialize(data={})
+      # Setup default instrumentation values
+      @@instrumentation.each do |k|
+        @@config[k] = {}
+        @@config[k][:enabled] = true
+        @@config[k][:collect_backtraces] = false
+        @@config[k][:log_args] = true
+      end
+
+      # Set collect_backtraces defaults
+      Oboe::Config[:action_controller][:collect_backtraces] = true
+      Oboe::Config[:active_record][:collect_backtraces] = true
+      Oboe::Config[:action_view][:collect_backtraces] = true
+      Oboe::Config[:cassandra][:collect_backtraces] = true
+      Oboe::Config[:dalli][:collect_backtraces] = false
+      Oboe::Config[:memcache][:collect_backtraces] = false
+      Oboe::Config[:memcached][:collect_backtraces] = false
+      Oboe::Config[:mongo][:collect_backtraces] = true
+      Oboe::Config[:moped][:collect_backtraces] = true
+      Oboe::Config[:nethttp][:collect_backtraces] = true
+      Oboe::Config[:redis][:collect_backtraces] = false
+      Oboe::Config[:resque][:collect_backtraces] = true
+
+      # Special instrument specific flags
+      #
+      # :link_workers - associates enqueue operations with the jobs they queue by piggybacking
+      #                 an additional argument that is stripped prior to job proecessing
+      #                 !!Note: Make sure both the queue side and the Resque workers are instrumented
+      #                 or jobs will fail
+      #                 (Default: false)
+      @@config[:resque][:link_workers] = false
+
+      # Setup an empty host blacklist (see: Oboe::API::Util.blacklisted?)
+      @@config[:blacklist] = []
+
+      # Access Key is empty until loaded from config file or env var
+      @@config[:access_key] = ""
+
+      # The oboe Ruby client has the ability to sanitize query literals
+      # from SQL statements.  By default this is disabled.  Enable to
+      # avoid collecting and reporting query literals to TraceView.
+      @@config[:sanitize_sql] = false
+
+      if ENV.has_key?('OPENSHIFT_TRACEVIEW_TLYZER_IP')
+        # We're running on OpenShift
+        @@config[:tracing_mode] = "always"
+        @@config[:reporter_host] = ENV['OPENSHIFT_TRACEVIEW_TLYZER_IP']
+        @@config[:reporter_port] = ENV['OPENSHIFT_TRACEVIEW_TLYZER_PORT']
+      else
+        # The default configuration
+        @@config[:tracing_mode] = "through"
+        @@config[:reporter_host] = "127.0.0.1"
+        @@config[:reporter_port] = "7831"
+      end
+
+      @@config[:verbose] = false
+    end
+
+    def self.update!(data)
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def self.merge!(data)
+      self.update!(data)
+    end
+
+    def self.[](key)
+      @@config[key.to_sym]
+    end
+
+    def self.[]=(key, value)
+      @@config[key.to_sym] = value
+
+      if key == :sampling_rate
+        Oboe.logger.warn "WARNING: :sampling_rate is not a supported setting for Oboe::Config.  Please use :sample_rate."
+      end
+
+      if key == :sample_rate
+        unless value.is_a?(Integer) or value.is_a?(Float)
+          raise "oboe :sample_rate must be a number between 1 and 1000000 (1m)"
+        end
+
+        # Validate :sample_rate value
+        unless value.between?(1, 1e6)
+          raise "oboe :sample_rate must be between 1 and 1000000 (1m)"
+        end
+
+        # Assure value is an integer
+        @@config[key.to_sym] = value.to_i
+
+        Oboe.set_sample_rate(value)
+      end
+
+      # Update liboboe if updating :tracing_mode
+      if key == :tracing_mode
+        Oboe.set_tracing_mode(value)
+      end
+    end
+
+    def self.method_missing(sym, *args)
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        unless @@config.has_key?(sym)
+          Oboe.logger.warn "[oboe/warn] Unknown method call on Oboe::Config: #{sym}"
+        end
+        self[sym]
+      end
+    end
+  end
+end
+
+Oboe::Config.initialize
+

data/lib/oboe/frameworks/grape.rb

@@ -0,0 +1,74 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Grape
+    module API
+      def self.extended(klass)
+        ::Oboe::Util.class_method_alias(klass, :inherited, ::Grape::API)
+      end
+
+      def inherited_with_oboe(subclass)
+        inherited_without_oboe(subclass)
+
+        subclass.use ::Oboe::Rack
+      end
+    end
+
+    module Endpoint
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :run, ::Grape::Endpoint)
+      end
+
+      def run_with_oboe(env)
+        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('grape', {})
+
+          begin
+            run_without_oboe(env)
+          ensure
+            ::Oboe::API.log_exit('grape', report_kvs)
+          end
+        else
+          run_without_oboe(env)
+        end
+      end
+    end
+
+    module Middleware
+      module Error
+        def self.included(klass)
+          ::Oboe::Util.method_alias(klass, :call, ::Grape::Middleware::Error)
+        end
+
+        def call_with_oboe(boom)
+          Oboe::API.log_exception(nil, boom) if Oboe.tracing?
+          call_without_oboe(boom)
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Grape)
+  require 'oboe/inst/rack'
+
+  Oboe.logger.info "[oboe/loading] Instrumenting Grape" if Oboe::Config[:verbose]
+
+  Oboe::Loading.load_access_key
+  Oboe::Inst.load_instrumentation
+
+  ::Oboe::Util.send_extend(::Grape::API,               ::Oboe::Grape::API)
+  ::Oboe::Util.send_include(::Grape::Endpoint,          ::Oboe::Grape::Endpoint)
+  ::Oboe::Util.send_include(::Grape::Middleware::Error, ::Oboe::Grape::Middleware::Error)
+end
+

data/lib/oboe/frameworks/padrino.rb

@@ -0,0 +1,66 @@
+# 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
+
+    # Report __Init after fork when in Heroku
+    Oboe::API.report_init unless Oboe.heroku?
+  end
+
+end
+

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

@@ -0,0 +1,59 @@
+# 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)
+        unless Oboe.tracing?
+          render_without_oboe(engine, data, options, locals, &block)
+        else
+          report_kvs = {}
+
+          if data
+            report_kvs[:engine] = engine
+            report_kvs[:template] = data
+          else
+            report_kvs[:template] = engine
+          end
+
+          if Oboe.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
+