oboe 2.7.0.3-java

data/lib/oboe/instrumentation.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Inst
+    def self.load_instrumentation
+      # Load the general instrumentation
+      pattern = File.join(File.dirname(__FILE__), 'inst', '*.rb')
+      Dir.glob(pattern) do |f|
+        begin
+          require f
+        rescue => e
+          Oboe.logger.error "[oboe/loading] Error loading instrumentation file '#{f}' : #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/oboe/loading.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'digest/sha1'
+
+module Oboe
+  module Util
+    ##
+    # This module is used solely for RUM ID calculation
+    #
+    module Base64URL
+      module_function
+
+      def encode(bin)
+        c = [bin].pack('m0').gsub(/\=+\Z/, '').tr('+/', '-_').rstrip
+        m = c.size % 4
+        c += '=' * (4 - m) if m != 0
+        c
+      end
+
+      def decode(bin)
+        m = bin.size % 4
+        bin += '=' * (4 - m) if m != 0
+        bin.tr('-_', '+/').unpack('m0').first
+      end
+    end
+  end
+
+  ##
+  # This module houses all of the loading functionality for the oboe gem.
+  #
+  # Note that this does not necessarily _have_ to include initialization routines
+  # (although it can).
+  #
+  # Actual initialization is often separated out as it can be dependent on on the state
+  # of the stack boot process.  e.g. code requiring that initializers, frameworks or
+  # instrumented libraries are already loaded...
+  #
+  module Loading
+    ##
+    # Load the TraceView access key (either from system configuration file
+    # or environment variable) and calculate internal RUM ID
+    #
+    def self.load_access_key
+      begin
+        if ENV.has_key?('TRACEVIEW_CUUID')
+          # Preferably get access key from environment (e.g. Heroku)
+          Oboe::Config[:access_key] = ENV['TRACEVIEW_CUUID']
+          Oboe::Config[:rum_id] = Oboe::Util::Base64URL.encode(Digest::SHA1.digest("RUM" + Oboe::Config[:access_key]))
+        else
+          # ..else read from system-wide configuration file
+          if Oboe::Config.access_key.empty?
+            config_file = '/etc/tracelytics.conf'
+            return unless File.exists?(config_file)
+
+            File.open(config_file).each do |line|
+              if line =~ /^tracelyzer.access_key=/ or line =~ /^access_key/
+                bits = line.split(/=/)
+                Oboe::Config[:access_key] = bits[1].strip
+                Oboe::Config[:rum_id] = Oboe::Util::Base64URL.encode(Digest::SHA1.digest("RUM" + Oboe::Config[:access_key]))
+                break
+              end
+            end
+          end
+        end
+      rescue StandardError => e
+        Oboe.logger.error "Trouble obtaining access_key and rum_id: #{e.inspect}"
+      end
+    end
+
+    ##
+    # Load the oboe tracing API
+    #
+    def self.require_api
+      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.logger.fatal "[oboe/error] Couldn't load oboe api."
+      end
+    end
+  end
+end
+
+Oboe::Loading.require_api
+
+# Auto-start the Reporter unless we running Unicorn on Heroku
+# In that case, we start the reporters after fork
+unless Oboe.heroku? and Oboe.forking_webserver?
+  Oboe.logger.debug "[oboe/debug] starting Reporter from oboe gem"
+  Oboe::Reporter.start
+end
+

data/lib/oboe/logger.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'logger'
+
+module Oboe
+  class << self
+    attr_accessor :logger
+  end
+
+  class Logger
+    # Fatal message
+    def fatal(string, exception = nil)
+      Oboe.logger.fatal(string) if Oboe.logger
+    end
+
+    # Error message
+    def error(msg, exception = nil)
+      Oboe.logger.error(string) if Oboe.logger
+    end
+
+    # Warn message
+    def warn(msg, exception = nil)
+      Oboe.logger.warn(string) if Oboe.logger
+    end
+
+    # Info message
+    def info(msg, exception = nil)
+      Oboe.logger.info(string) if Oboe.logger
+    end
+
+    # Debug message
+    def debug(msg, exception = nil)
+      Oboe.logger.debug(string) if Oboe.logger
+    end
+
+  end
+end
+
+Oboe.logger = Logger.new(STDERR)
+

data/lib/oboe/ruby.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Ruby
+    def self.initialize
+      Oboe::Loading.load_access_key
+      Oboe::Inst.load_instrumentation
+    end
+  end
+end

data/lib/oboe/util.rb

@@ -0,0 +1,129 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Util
+    class << self
+      def contextual_name(cls)
+        # Attempt to infer a contextual name if not indicated
+        #
+        # For example:
+        # ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.to_s.split(/::/).last
+        # => "AbstractMysqlAdapter"
+        #
+        begin
+          cls.to_s.split(/::/).last
+        rescue
+        end
+      end
+
+      ##
+      # method_alias
+      #
+      # Centralized utility method to alias a method on an arbitrary
+      # class or module.
+      #
+      def method_alias(cls, method, name=nil)
+        name ||= contextual_name(cls)
+
+        if cls.method_defined? method.to_sym or cls.private_method_defined? method.to_sym
+
+          # 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
+      end
+
+      ##
+      # class_method_alias
+      #
+      # Centralized utility method to alias a class method on an arbitrary
+      # class or module
+      #
+      def class_method_alias(cls, method, name=nil)
+        name ||= contextual_name(cls)
+
+        if cls.singleton_methods.include? method.to_sym
+
+          # 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.singleton_methods.include? without_oboe.to_sym
+            cls.singleton_class.send(:alias_method, without_oboe, "#{method}")
+            cls.singleton_class.send(:alias_method, "#{method}", with_oboe)
+          end
+        else Oboe.logger.warn "[oboe/loading] Couldn't properly instrument #{name}.  Partial traces may occur."
+        end
+      end
+
+      ##
+      # send_extend
+      #
+      # Centralized utility method to send an extend call for an
+      # arbitrary class
+      def send_extend(target_cls, cls)
+        if defined?(target_cls)
+          target_cls.send(:extend, cls)
+        end
+      end
+
+      ##
+      # send_include
+      #
+      # Centralized utility method to send a include call for an
+      # arbitrary class
+      def send_include(target_cls, cls)
+        if defined?(target_cls)
+          target_cls.send(:include, cls)
+        end
+      end
+
+      ##
+      # static_asset?
+      #
+      # Given a path, this method determines whether it is a static asset or not (based
+      # solely on filename)
+      #
+      def static_asset?(path)
+        return (path =~ /\.(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|ttf|woff|svg|less)$/i)
+      end
+
+      ##
+      # prettify
+      #
+      # Even to my surprise, 'prettify' is a real word:
+      # transitive v. To make pretty or prettier, especially in a superficial or insubstantial way.
+      #   from The American Heritage® Dictionary of the English Language, 4th Edition
+      #
+      # This method makes things 'purty' for reporting.
+      def prettify(x)
+        if (x.to_s =~ /^#</) == 0
+          x.class.to_s
+        else
+          x.to_s
+        end
+      end
+
+    end
+  end
+end
+

data/lib/oboe/version.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Version
+    MAJOR = 2
+    MINOR = 7
+    PATCH = 0
+    BUILD = 3
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/lib/oboe/xtrace.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module XTrace
+    class << self
+
+      ##
+      #  Oboe::XTrace.valid?
+      #
+      #  Perform basic validation on a potential X-Trace ID
+      #
+      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
+
+          # Valid X-Trace IDs have a length of 58 bytes and start with '1b'
+          return false unless xtrace.length == 58 and (xtrace =~ /^1b/i) == 0
+
+          true
+        rescue StandardError => e
+          Oboe.logger.debug e.message
+          Oboe.logger.debug e.backtrace
+          false
+        end
+      end
+
+      ##
+      # Oboe::XTrace.task_id
+      #
+      # Extract and return the task_id portion of an X-Trace ID
+      #
+      def task_id(xtrace)
+        begin
+          return nil unless Oboe::XTrace.valid?(xtrace)
+
+          xtrace[2..41]
+        rescue StandardError => e
+          Oboe.logger.debug e.message
+          Oboe.logger.debug e.backtrace
+          return nil
+        end
+      end
+
+    end
+  end
+end
+

data/lib/oboe_metal.rb

@@ -0,0 +1,140 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'base'
+
+module Oboe
+  extend OboeBase
+  include Oboe_metal
+
+  class Reporter
+    ##
+    # Initialize the Oboe Context, reporter and report the initialization
+    #
+    def self.start
+      return unless Oboe.loaded
+
+      begin
+        Oboe_metal::Context.init()
+
+        if ENV.has_key?("OBOE_GEM_TEST")
+          Oboe.reporter = Oboe::FileReporter.new("/tmp/trace_output.bson")
+        else
+          Oboe.reporter = Oboe::UdpReporter.new(Oboe::Config[:reporter_host], Oboe::Config[:reporter_port])
+        end
+
+        # Only report __Init from here if we are not instrumenting a framework.
+        # Otherwise, frameworks will handle reporting __Init after full initialization
+        unless defined?(::Rails) or defined?(::Sinatra) or defined?(::Padrino) or defined?(::Grape)
+          Oboe::API.report_init
+        end
+
+      rescue Exception => e
+        $stderr.puts e.message
+        raise
+      end
+    end
+
+    def self.sendReport(evt)
+      Oboe.reporter.sendReport(evt)
+    end
+
+    ##
+    # clear_all_traces
+    #
+    # Truncates the trace output file to zero
+    #
+    def self.clear_all_traces
+      File.truncate($trace_file, 0)
+    end
+
+    ##
+    # get_all_traces
+    #
+    # Retrieves all traces written to the trace file
+    #
+    def self.get_all_traces
+      io = File.open($trace_file, "r")
+      contents = io.readlines(nil)
+
+      return contents if contents.empty?
+
+      s = StringIO.new(contents[0])
+
+      traces = []
+
+      until s.eof?
+        if ::BSON.respond_to? :read_bson_document
+          traces << BSON.read_bson_document(s)
+        else
+          traces << BSON::Document.from_bson(s)
+        end
+      end
+
+      traces
+    end
+  end
+
+  class Event
+    def self.metadataString(evt)
+      evt.metadataString()
+    end
+  end
+
+  class << self
+    def sample?(opts = {})
+      begin
+        return false unless Oboe.always?
+
+        # Assure defaults since SWIG enforces Strings
+        layer   = opts[:layer]      ? opts[:layer].strip      : ''
+        xtrace  = opts[:xtrace]     ? opts[:xtrace].strip     : ''
+        tv_meta = opts['X-TV-Meta'] ? opts['X-TV-Meta'].strip : ''
+
+        rv = Oboe::Context.sampleRequest(layer, xtrace, tv_meta)
+
+        # For older liboboe that returns true/false, just return that.
+        return rv if [TrueClass, FalseClass].include?(rv.class) or (rv == 0)
+
+        # liboboe version > 1.3.1 returning a bit masked integer with SampleRate and
+        # source embedded
+        Oboe.sample_rate = (rv & SAMPLE_RATE_MASK)
+        Oboe.sample_source = (rv & SAMPLE_SOURCE_MASK) >> 24
+      rescue StandardError => e
+        Oboe.logger.debug "[oboe/error] sample? error: #{e.inspect}"
+        false
+      end
+    end
+
+    def set_tracing_mode(mode)
+      return unless Oboe.loaded
+
+      value = mode.to_sym
+
+      case value
+      when :never
+        Oboe::Context.setTracingMode(OBOE_TRACE_NEVER)
+
+      when :always
+        Oboe::Context.setTracingMode(OBOE_TRACE_ALWAYS)
+
+      when :through
+        Oboe::Context.setTracingMode(OBOE_TRACE_THROUGH)
+
+      else
+        Oboe.logger.fatal "[oboe/error] Invalid tracing mode set: #{mode}"
+        Oboe::Context.setTracingMode(OBOE_TRACE_THROUGH)
+      end
+    end
+
+    def set_sample_rate(rate)
+      if Oboe.loaded
+        # Update liboboe with the new SampleRate value
+        Oboe::Context.setDefaultSampleRate(rate.to_i)
+      end
+    end
+  end
+end
+
+Oboe.loaded = true
+