traceview 3.0.0

data/lib/traceview/config.rb

@@ -0,0 +1,238 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  ##
+  # This module exposes a nested configuration hash that can be used to
+  # configure and/or modify the functionality of the traceview gem.
+  #
+  # Use TraceView::Config.show to view the entire nested hash.
+  #
+  module Config
+    @@config = {}
+
+    @@instrumentation = [:action_controller, :action_view, :active_record,
+                         :cassandra, :dalli, :em_http_request, :excon, :faraday,
+                         :grape, :httpclient, :nethttp, :memcached, :memcache, :mongo,
+                         :moped, :rack, :redis, :resque, :rest_client, :sequel,
+                         :typhoeus]
+
+    # Subgrouping of instrumentation
+    @@http_clients = [:excon, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+
+    ##
+    # 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
+
+      # Beta instrumentation disabled by default
+      TraceView::Config[:em_http_request][:enabled] = false
+
+      # Set collect_backtraces defaults
+      TraceView::Config[:action_controller][:collect_backtraces] = true
+      TraceView::Config[:active_record][:collect_backtraces] = true
+      TraceView::Config[:action_view][:collect_backtraces] = true
+      TraceView::Config[:cassandra][:collect_backtraces] = true
+      TraceView::Config[:dalli][:collect_backtraces] = false
+      TraceView::Config[:em_http_request][:collect_backtraces] = false
+      TraceView::Config[:excon][:collect_backtraces] = true
+      TraceView::Config[:faraday][:collect_backtraces] = false
+      TraceView::Config[:grape][:collect_backtraces] = true
+      TraceView::Config[:httpclient][:collect_backtraces] = true
+      TraceView::Config[:memcache][:collect_backtraces] = false
+      TraceView::Config[:memcached][:collect_backtraces] = false
+      TraceView::Config[:mongo][:collect_backtraces] = true
+      TraceView::Config[:moped][:collect_backtraces] = true
+      TraceView::Config[:nethttp][:collect_backtraces] = true
+      TraceView::Config[:redis][:collect_backtraces] = false
+      TraceView::Config[:resque][:collect_backtraces] = true
+      TraceView::Config[:rest_client][:collect_backtraces] = false
+      TraceView::Config[:sequel][:collect_backtraces] = true
+      TraceView::Config[:typhoeus][:collect_backtraces] = false
+
+      # 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: TraceView::API::Util.blacklisted?)
+      @@config[:blacklist] = []
+
+      # Access Key is empty until loaded from config file or env var
+      @@config[:access_key] = ''
+
+      # Logging of outgoing HTTP query args
+      #
+      # This optionally disables the logging of query args of outgoing
+      # HTTP clients such as Net::HTTP, excon, typhoeus and others.
+      #
+      # This flag is global to all HTTP client instrumentation.
+      #
+      # To configure this on a per instrumentation basis, set this
+      # option to true and instead disable the instrumenstation specific
+      # option <tt>log_args</tt>:
+      #
+      #   TraceView::Config[:nethttp][:log_args] = false
+      #   TraceView::Config[:excon][:log_args] = false
+      #   TraceView::Config[:typhoeus][:log_args] = true
+      #
+      @@config[:include_url_query_params] = true
+
+      # Logging of incoming HTTP query args
+      #
+      # This optionally disables the logging of incoming URL request
+      # query args.
+      #
+      # This flag is global and currently only affects the Rack
+      # instrumentation which reports incoming request URLs and
+      # query args by default.
+      @@config[:include_remote_url_params] = true
+
+      # The TraceView Ruby gem 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
+
+      # Do Not Trace
+      # These two values allow you to configure specific URL patterns to
+      # never be traced.  By default, this is set to common static file
+      # extensions but you may want to customize this list for your needs.
+      #
+      # dnt_regexp and dnt_opts is passed to Regexp.new to create
+      # a regular expression object.  That is then used to match against
+      # the incoming request path.
+      #
+      # The path string originates from the rack layer and is retrieved
+      # as follows:
+      #
+      #   req = ::Rack::Request.new(env)
+      #   path = URI.unescape(req.path)
+      #
+      # Usage:
+      #   TraceView::Config[:dnt_regexp] = "lobster$"
+      #   TraceView::Config[:dnt_opts]   = Regexp::IGNORECASE
+      #
+      # This will ignore all requests that end with the string lobster
+      # regardless of case
+      #
+      # Requests with positive matches (non nil) will not be traced.
+      # See lib/traceview/util.rb: TraceView::Util.static_asset?
+      #
+      @@config[:dnt_regexp] = "\.(jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|pdf|txt|tar|wav|bmp|rtf|js|flv|swf|ttf|woff|svg|less)$"
+      @@config[:dnt_opts]   = Regexp::IGNORECASE
+
+      # In Rails, raised exceptions with rescue handlers via
+      # <tt>rescue_from</tt> are not reported to the TraceView
+      # dashboard by default.  Setting this value to true will
+      # report all raised exception regardless.
+      @@config[:report_rescued_errors] = false
+
+      # Environment support for OpenShift.
+      if ENV.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] = ENV.key?('TRACEVIEW_GEM_VERBOSE') ? true : 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
+        TraceView.logger.warn 'sampling_rate is not a supported setting for TraceView::Config.  ' \
+                         'Please use :sample_rate.'
+
+      elsif key == :sample_rate
+        unless value.is_a?(Integer) || value.is_a?(Float)
+          fail 'traceview :sample_rate must be a number between 1 and 1000000 (1m)'
+        end
+
+        # Validate :sample_rate value
+        unless value.between?(1, 1e6)
+          fail 'traceview :sample_rate must be between 1 and 1000000 (1m)'
+        end
+
+        # Assure value is an integer
+        @@config[key.to_sym] = value.to_i
+        TraceView.set_sample_rate(value) if TraceView.loaded
+
+      elsif key == :include_url_query_params
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@http_clients.each do |i|
+          @@config[i][:log_args] = value
+        end
+
+      elsif key == :include_remote_url_params
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@config[:rack][:log_args] = value
+      end
+
+      # Update liboboe if updating :tracing_mode
+      if key == :tracing_mode
+        TraceView.set_tracing_mode(value) if TraceView.loaded
+      end
+    end
+
+    def self.method_missing(sym, *args)
+      class_var_name = "@@#{sym}"
+
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        # Try part of the @@config hash first
+        if @@config.key?(sym)
+          self[sym]
+
+        # Then try as a class variable
+        elsif self.class_variable_defined?(class_var_name.to_sym)
+          self.class_eval(class_var_name)
+
+        # Congrats - You've won a brand new nil...
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+TraceView::Config.initialize

data/lib/traceview/frameworks/grape.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Grape
+    module API
+      def self.extended(klass)
+        ::TraceView::Util.class_method_alias(klass, :inherited, ::Grape::API)
+      end
+
+      def inherited_with_traceview(subclass)
+        inherited_without_traceview(subclass)
+
+        subclass.use ::TraceView::Rack
+      end
+    end
+
+    module Endpoint
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :run, ::Grape::Endpoint)
+      end
+
+      def run_with_traceview(env)
+        if TraceView.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 TraceView::API.trace
+          # block method) This removes the need for an info
+          # event to send additonal KVs
+          ::TraceView::API.log_entry('grape', {})
+
+          begin
+            run_without_traceview(env)
+          ensure
+            ::TraceView::API.log_exit('grape', report_kvs)
+          end
+        else
+          run_without_traceview(env)
+        end
+      end
+    end
+
+    module Middleware
+      module Error
+        def self.included(klass)
+          ::TraceView::Util.method_alias(klass, :error_response, ::Grape::Middleware::Error)
+        end
+
+        def error_response_with_traceview(error = {})
+          status, headers, body = error_response_without_traceview(error)
+
+          if TraceView.tracing?
+            # Since Grape uses throw/catch and not Exceptions, we manually log
+            # the error here.
+            kvs = {}
+            kvs[:ErrorClass] = 'GrapeError'
+            kvs[:ErrorMsg] = error[:message] ? error[:message] : "No message given."
+            kvs[:Backtrace] = ::TraceView::API.backtrace if TraceView::Config[:grape][:collect_backtraces]
+
+            ::TraceView::API.log(nil, 'error', kvs)
+
+            # Since calls to error() are handled similar to abort in Grape.  We
+            # manually log the rack exit here since the original code won't
+            # be returned to
+            xtrace = TraceView::API.log_end('rack', :Status => status)
+
+            if headers && TraceView::XTrace.valid?(xtrace)
+              unless defined?(JRUBY_VERSION) && TraceView.is_continued_trace?
+                headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+              end
+            end
+          end
+
+          [status, headers, body]
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Grape)
+  require 'traceview/inst/rack'
+
+  TraceView.logger.info "[traceview/loading] Instrumenting Grape" if TraceView::Config[:verbose]
+
+  TraceView::Loading.load_access_key
+  TraceView::Inst.load_instrumentation
+
+  ::TraceView::Util.send_extend(::Grape::API,               ::TraceView::Grape::API)
+  ::TraceView::Util.send_include(::Grape::Endpoint,          ::TraceView::Grape::Endpoint)
+  ::TraceView::Util.send_include(::Grape::Middleware::Error, ::TraceView::Grape::Middleware::Error)
+end
+

data/lib/traceview/frameworks/padrino.rb

@@ -0,0 +1,64 @@
+# Copyright (c) 2014 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module PadrinoInst
+    module Routing
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+      end
+
+      def dispatch_with_traceview
+        if TraceView.tracing?
+          report_kvs = {}
+
+          # Fall back to the raw tracing API so we can pass KVs
+          # back on exit (a limitation of the TraceView::API.trace
+          # block method) This removes the need for an info
+          # event to send additonal KVs
+          ::TraceView::API.log_entry('padrino', {})
+
+          begin
+            r = dispatch_without_traceview
+
+            # 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
+            ::TraceView::API.log_exit('padrino', report_kvs)
+          end
+        else
+          dispatch_without_traceview
+        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.
+  ::TraceView.logger.info "[traceview/loading] Instrumenting Padrino" if TraceView::Config[:verbose]
+
+  require 'traceview/frameworks/padrino/templates'
+
+  Padrino.after_load do
+    ::TraceView.logger = ::Padrino.logger if ::Padrino.respond_to?(:logger)
+    ::TraceView::Loading.load_access_key
+    ::TraceView::Inst.load_instrumentation
+
+    ::TraceView::Util.send_include(::Padrino::Routing::InstanceMethods, ::TraceView::PadrinoInst::Routing)
+    if defined?(::Padrino::Rendering)
+      ::TraceView::Util.send_include(::Padrino::Rendering::InstanceMethods, ::TraceView::PadrinoInst::Rendering)
+    end
+
+    # Report __Init after fork when in Heroku
+    TraceView::API.report_init unless TraceView.heroku?
+  end
+end

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

@@ -0,0 +1,58 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module PadrinoInst
+    module Rendering
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      def render_with_traceview(engine, data = nil, options = {}, locals = {}, &block)
+        if TraceView.tracing?
+          report_kvs = {}
+
+          if data
+            report_kvs[:engine] = engine
+            report_kvs[:template] = data
+          else
+            report_kvs[:template] = engine
+          end
+
+          if TraceView.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
+              ::TraceView.logger.debug e.message
+              ::TraceView.logger.debug e.backtrace.join(', ')
+            end
+
+            TraceView::API.profile(report_kvs[:template], report_kvs, false) do
+              render_without_traceview(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 TraceView::API.trace
+            # block method) This removes the need for an info
+            # event to send additonal KVs
+            ::TraceView::API.log_entry('render', {}, 'render')
+
+            begin
+              render_without_traceview(engine, data, options, locals, &block)
+            ensure
+              ::TraceView::API.log_exit('render', report_kvs)
+            end
+          end
+        else
+          render_without_traceview(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end