sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/control/frameworks/sinatra.rb

@@ -0,0 +1,20 @@
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Sinatra
+      class Sinatra < NewRelic::Control::Frameworks::Ruby
+
+        def env
+          @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+        end
+
+        def init_config(options={})
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/control/instance_methods.rb

@@ -0,0 +1,145 @@
+require 'new_relic/language_support'
+require 'new_relic/agent/agent_logger'
+
+module NewRelic
+  class Control
+    include NewRelic::LanguageSupport::Control
+
+    # Contains methods that relate to the runtime usage of the control
+    # object. Note that these are subject to override in the
+    # NewRelic::Control::Framework classes that are actually instantiated
+    module InstanceMethods
+      # The env is the setting used to identify which section of the newrelic.yml
+      # to load.  This defaults to a framework specific value, such as ENV['RAILS_ENV']
+      # but can be overridden as long as you set it before calling #init_plugin
+      attr_writer :env
+
+      # The local environment contains all the information we report
+      # to the server about what kind of application this is, what
+      # gems and plugins it uses, and many other kinds of
+      # machine-dependent information useful in debugging
+      attr_reader :local_env
+
+      # Initialize the plugin/gem and start the agent.  This does the
+      # necessary configuration based on the framework environment and
+      # determines whether or not to start the agent.  If the agent is
+      # not going to be started then it loads the agent shim which has
+      # stubs for all the external api.
+      #
+      # This may be invoked multiple times, as long as you don't attempt
+      # to uninstall the agent after it has been started.
+      #
+      # If the plugin is initialized and it determines that the agent is
+      # not enabled, it will skip starting it and install the shim.  But
+      # if you later call this with <tt>:agent_enabled => true</tt>,
+      # then it will install the real agent and start it.
+      #
+      # What determines whether the agent is launched is the result of
+      # calling agent_enabled?  This will indicate whether the
+      # instrumentation should/will be installed.  If we're in a mode
+      # where tracers are not installed then we should not start the
+      # agent.
+      #
+      # Subclasses are not allowed to override, but must implement
+      # init_config({}) which is called one or more times.
+      #
+      def init_plugin(options={})
+        yaml = Agent::Configuration::YamlSource.new(@config_file_path, options[:env] || env)
+        Agent.config.replace_or_add_config(yaml, 1)
+
+        Agent.config.replace_or_add_config(Agent::Configuration::ManualSource.new(options), 1)
+
+        # Be sure to only create once! RUBY-1020
+        if ::NewRelic::Agent.logger.is_startup_logger?
+          ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(Agent.config, root, options.delete(:log))
+        end
+
+        # Merge the stringified options into the config as overrides:
+        environment_name = options.delete(:env) and self.env = environment_name
+        dispatcher_instance_id = options.delete(:dispatcher_instance_id) and @local_env.dispatcher_instance_id = dispatcher_instance_id
+
+        NewRelic::Agent::PipeChannelManager.listener.start if options.delete(:start_channel_listener)
+
+        # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
+        # methods in the module methods.
+        Module.send :include, NewRelic::Agent::MethodTracer::ClassMethods
+        Module.send :include, NewRelic::Agent::MethodTracer::InstanceMethods
+        init_config(options)
+        NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
+        if Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
+          start_agent
+          install_instrumentation
+          load_samplers unless Agent.config[:disable_samplers]
+          local_env.gather_environment_info
+          append_environment_info
+        elsif !Agent.config[:agent_enabled]
+          install_shim
+        end
+      end
+
+      # Install the real agent into the Agent module, and issue the start command.
+      def start_agent
+        NewRelic::Agent.agent.start
+      end
+
+      def app
+        Agent.config[:framework]
+      end
+
+      def framework
+        Agent.config[:framework]
+      end
+
+      # for backward compatibility with the old config interface
+      def [](key)
+        NewRelic::Agent.config[key.to_sym]
+      end
+
+      def settings
+        NewRelic::Agent.config.to_collector_hash
+      end
+
+      def dispatcher
+        NewRelic::Agent.config[:dispatcher]
+      end
+
+      # Delegates to the class method newrelic_root, implemented by
+      # each subclass
+      def newrelic_root
+        self.class.newrelic_root
+      end
+
+      protected
+
+      # Append framework specific environment information for uploading to
+      # the server for change detection.  Override in subclasses
+      def append_environment_info; end
+
+      # Asks bundler to tell us which gemspecs are loaded in the
+      # current process
+      def bundler_gem_list
+        if defined?(Bundler) && Bundler.instance_eval do @load end
+          Bundler.load.specs.map do |spec|
+            version = (spec.respond_to?(:version) && spec.version)
+            spec.name + (version ? "(#{version})" : "")
+          end
+        else
+          []
+        end
+      end
+
+
+      def initialize(local_env, config_file_override=nil)
+        @local_env = local_env
+        @instrumentation_files = []
+        @config_file_path = config_file_override || Agent.config[:config_path]
+      end
+
+      def root
+        '.'
+      end
+
+    end
+    include InstanceMethods
+  end
+end

data/lib/new_relic/control/instrumentation.rb

@@ -0,0 +1,95 @@
+module NewRelic
+  class Control
+    # Contains methods that relate to adding and executing files that
+    # contain instrumentation for the Ruby Agent
+    module Instrumentation
+
+      # Adds a list of files in Dir.glob format
+      # (e.g. '/app/foo/**/*_instrumentation.rb')
+      # This requires the files within a rescue block, so that any
+      # errors within instrumentation files do not affect the overall
+      # agent or application in which it runs.
+      def load_instrumentation_files pattern
+        Dir.glob(pattern) do |file|
+          begin
+            require file.to_s
+          rescue => e
+            ::NewRelic::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+          end
+        end
+      end
+
+      # Install stubs to the proper location so the app code will not fail
+      # if the agent is not running.
+      def install_shim
+        # Once we install instrumentation, you can't undo that by installing the shim.
+        raise "Cannot install the Agent shim after instrumentation has already been installed!" if @instrumented
+        NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
+      end
+
+      # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
+      # This will load the file synchronously if we've already loaded the default
+      # instrumentation, otherwise instrumentation files specified
+      # here will be deferred until all instrumentation is run
+      #
+      # This happens after the agent has loaded and all dependencies
+      # are ready to be instrumented
+      def add_instrumentation pattern
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+      
+      # Signals the agent that it's time to actually load the
+      # instrumentation files. May be overridden by subclasses
+      def install_instrumentation
+        _install_instrumentation
+      end
+      
+      # adds samplers to the stats engine so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses NewRelic::Agent::Sampler
+      def load_samplers
+        agent = NewRelic::Agent.instance
+        NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
+          begin
+            ::NewRelic::Agent.logger.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+            sampler = subclass.new
+            if subclass.use_harvest_sampler?
+              agent.stats_engine.add_harvest_sampler sampler
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for harvest time sampling"
+            else
+              agent.stats_engine.add_sampler sampler
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for periodic sampling"
+            end
+          rescue NewRelic::Agent::Sampler::Unsupported => e
+            ::NewRelic::Agent.logger.info "#{subclass} sampler not available: #{e}"
+          rescue => e
+            ::NewRelic::Agent.logger.error "Error registering sampler:", e
+          end
+        end
+      end
+
+      private
+
+      def _install_instrumentation
+        return if @instrumented
+
+        @instrumented = true
+
+        # Instrumentation for the key code points inside rails for monitoring by NewRelic.
+        # note this file is loaded only if the newrelic agent is enabled (through config/newrelic.yml)
+        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'agent','instrumentation'))
+        @instrumentation_files <<
+        File.join(instrumentation_path, '*.rb') <<
+        File.join(instrumentation_path, app.to_s, '*.rb')
+        @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
+        DependencyDetection.detect!
+        ::NewRelic::Agent.logger.info "Finished instrumentation"
+      end
+    end
+    include Instrumentation
+  end
+end

data/lib/new_relic/control/profiling.rb

@@ -0,0 +1,25 @@
+module NewRelic
+  class Control
+    module Profiling
+
+      # A flag used in dev mode to indicate if profiling is available
+      def profiling?
+        @profiling
+      end
+
+      def profiling_available?
+        @profiling_available ||=
+          begin
+            require 'ruby-prof'
+            true
+          rescue LoadError; end
+      end
+      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+      # loaded a true value is ignored.
+      def profiling=(val)
+        @profiling = profiling_available? && val && defined?(RubyProf)
+      end
+    end
+    include Profiling
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,80 @@
+module NewRelic
+  class Control
+
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+
+    # Contains methods that deal with connecting to the server
+    module ServerMethods
+
+      def server
+        @remote_server ||= server_from_host(nil)
+      end
+
+      # the server we should contact for api requests, like uploading
+      # deployments and the like
+      def api_server
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], nil)
+      end
+
+      # a new instances of the proxy server - this passes through if
+      # there is no proxy, otherwise it has proxy configuration
+      # information pulled from the config file
+      def proxy_server
+        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
+                                                             Agent.config[:proxy_port],
+                                                             Agent.config[:proxy_user],
+                                                             Agent.config[:proxy_pass])
+      end
+
+      # turns a hostname into an ip address and returns a
+      # NewRelic::Control::Server that contains the configuration info
+      def server_from_host(hostname=nil)
+        host = hostname || Agent.config[:host]
+
+        # if the host is not an IP address, turn it into one
+        NewRelic::Control::Server.new(host, Agent.config[:port],
+                                      convert_to_ip_address(host))
+      end
+
+      # Check to see if we need to look up the IP address
+      # If it's an IP address already, we pass it through.
+      # If it's nil, or localhost, we don't bother.
+      # Otherwise, use `resolve_ip_address` to find one
+      def convert_to_ip_address(host)
+        # here we leave it as a host name since the cert verification
+        # needs it in host form
+        return host if Agent.config[:ssl] && Agent.config[:verify_certificate]
+        return nil if host.nil? || host.downcase == "localhost"
+        ip = resolve_ip_address(host)
+
+        ::NewRelic::Agent.logger.debug "Resolved #{host} to #{ip}"
+        ip
+      end
+
+      # Look up the ip address of the host using the pure ruby lookup
+      # to prevent blocking.  If that fails, fall back to the regular
+      # IPSocket library.  Return nil if we can't find the host ip
+      # address and don't have a good default.
+      def resolve_ip_address(host)
+        Resolv.getaddress(host)
+      rescue => e
+        ::NewRelic::Agent.logger.warn("DNS Error caching IP address:", e)
+        begin
+          ::NewRelic::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
+          IPSocket.getaddress(host)
+        rescue => e
+          ::NewRelic::Agent.logger.error("Could not look up server address: #{e}")
+          nil
+        end
+      end
+    end
+
+    include ServerMethods
+  end
+end
+

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,51 @@
+require 'dependency_detection'
+# This installs some code to manually start the agent when a delayed
+# job worker starts.  It's not really instrumentation.  It's more like
+# a hook from DJ to the Ruby Agent so it gets loaded at the time the
+# Ruby Agent initializes, which must be before the DJ worker
+# initializes.  Loaded from control.rb
+module NewRelic
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end
+
+DependencyDetection.defer do
+  @name = :delayed_job_injection
+  
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
+  end
+  
+  executes do
+    if NewRelic::Agent.respond_to?(:logger)
+      ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation hooks'
+    end
+  end
+  
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_new_relic(*args)
+        initialize_without_new_relic(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+        say "New Relic Ruby Agent Monitoring DJ worker #{dispatcher_instance_id}"
+        NewRelic::DelayedJobInjection.worker_name = worker_name
+        NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+      end
+
+      alias initialize_without_new_relic initialize
+      alias initialize initialize_with_new_relic
+    end
+  end
+end
+
+# If Rails is defined, this gets called in an after_initialize hook
+# see NewRelic::Control::Frameworks::Rails#init_config
+unless defined?(Rails)
+  DependencyDetection.detect!
+end

data/lib/new_relic/helper.rb

@@ -0,0 +1,66 @@
+#encoding: utf-8
+
+module NewRelic
+  # A singleton for shared generic helper methods
+  module Helper
+    extend self
+
+    # confirm a string is correctly encoded (in >= 1.9)
+    # If not force the encoding to ASCII-8BIT (binary)
+    if RUBY_VERSION >= '1.9'
+      def correctly_encoded(string)
+        return string unless string.is_a? String
+        string.valid_encoding? ? string : string.force_encoding("ASCII-8BIT")
+      end
+    else
+      #noop
+      def correctly_encoded(string)
+        string
+      end
+    end
+
+    def instance_method_visibility(klass, method_name)
+      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :private
+      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+        :protected
+      else
+        :public
+      end
+    end
+
+    def time_to_millis(time)
+      (time.to_f * 1000).round
+    end
+  end
+
+  # Load the JSON library from the standard library.
+  def self::load_stdlib_json
+    # Don't even try to use 1.9.1's json.
+    return false if RUBY_VERSION == '1.9.1'
+
+    require 'json'
+    define_method( :json_dump, &::JSON.method(:dump) )
+    define_method( :json_load, &::JSON.method(:parse) )
+
+    return true
+  rescue LoadError
+    NewRelic::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
+      defined?( NewRelic::Agent ) && NewRelic::Agent.respond_to?( :logger )
+    return false
+  end
+
+
+  # Load the fallback JSON library
+  def self::load_okjson
+    require 'new_relic/okjson'
+    define_method( :json_dump, &::NewRelic::OkJson.method(:encode) )
+    define_method( :json_load, &::NewRelic::OkJson.method(:decode) )
+  end
+
+
+  load_stdlib_json or load_okjson
+  module_function :json_dump, :json_load
+
+end
+