tingyun_rpm 1.0.6

data/lib/ting_yun/environment_report.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/support/system_info'
+
+module TingYun
+  # The EnvironmentReport is responsible for analyzing the application's
+  # environment and generating the data for the Environment Report in TINGYUN
+  #
+  # It contains useful system information like Ruby version, OS, loaded gems,
+  # etc.
+  #
+  # Additional logic can be registered by using the EnvironmentReport.report_on
+  # hook.
+  class EnvironmentReport
+
+    # This is the main interface for registering logic that should be included
+    # in the Environment Report. For example:
+    #
+    # EnvironmentReport.report_on "Day of week" do
+    #   Time.now.strftime("%A")
+    # end
+    #
+    # The passed blocks will be run in EnvironmentReport instances on #initialize.
+    #
+    # Errors raised in passed blocks will be handled and logged at debug, so it
+    # is safe to report on things that may not work in certain environments.
+    #
+    # The blocks should only return strings or arrays full of strings.  Falsey
+    # values will be ignored.
+    def self.report_on(key, &block)
+      registered_reporters[key] = block
+    end
+
+    def self.registered_reporters
+      @registered_reporters ||= Hash.new
+    end
+
+    # allow the logic to be swapped out in tests
+    def self.registered_reporters=(logic)
+      @registered_reporters = logic
+    end
+
+    # register reporting logic
+    ####################################
+    report_on('Gems') do
+      begin
+       (Bundler.rubygems.all_specs.map { |gem| "#{gem.name}(#{gem.version})" }).join(',')
+      rescue
+        # There are certain rubygem, bundler, rails combinations (e.g. gem
+        # 1.6.2, rails 2.3, bundler 1.2.3) where the code above throws an error
+        # in bundler because of rails monkey patching gem.  The below does work
+        # though so try it if the above fails.
+        Bundler.load.specs.map do |spec|
+          version = (spec.respond_to?(:version) && spec.version)
+          spec.name + (version ? "(#{version})" : "")
+        end.join(',')
+      end
+    end
+    report_on('Plugin List') { ::Rails.configuration.plugins.to_a.join(',')}
+    report_on('Ruby version') { RUBY_VERSION }
+    report_on('Ruby description') { RUBY_DESCRIPTION }
+    report_on('Ruby platform') { RUBY_PLATFORM }
+    report_on('Ruby patchlevel') { RUBY_PATCHLEVEL.to_s }
+    report_on('JRuby version') { JRUBY_VERSION }
+    report_on('Java VM version') { ENV_JAVA['java.vm.version'] }
+    report_on('Logical Processors') { ::TingYun::Support::SystemInfo.num_logical_processors }
+    report_on('Physical Cores') { ::TingYun::Support::SystemInfo.num_physical_cores }
+    report_on('os_arch') { ::TingYun::Support::SystemInfo.processor_arch }
+    report_on('os_version') { ::TingYun::Support::SystemInfo.os_version }
+    report_on('kernel') { ::TingYun::Support::SystemInfo.ruby_os_identifier }
+    report_on('Database adapter') do
+      ActiveRecord::Base.configurations[::TingYun::Frameworks.framework.env]['adapter']
+    end
+    report_on('Framework') { TingYun::Agent.config[:framework].to_s }
+    report_on('Dispatcher') { TingYun::Agent.config[:dispatcher].to_s }
+    report_on('Environment') { ::TingYun::Frameworks.framework.env }
+    report_on('Rails version') { ::Rails::VERSION::STRING }
+    report_on('Rails threadsafe') do
+      ::Rails.configuration.action_controller.allow_concurrency
+    end
+    report_on('Rails Env') do
+      if defined? ::Rails and ::Rails.respond_to?(:env)
+        ::Rails.env.to_s
+      else
+        ENV['RAILS_ENV']
+      end
+    end
+    report_on('OpenSSL version') { ::OpenSSL::OPENSSL_VERSION }
+    # end reporting logic
+    ####################################
+
+
+    attr_reader :data
+    # Generate the report based on the class level logic.
+    def initialize
+      @data = self.class.registered_reporters.inject(Hash.new) do |data, (key, logic)|
+        begin
+          value = logic.call
+          if value
+            data[key] = value
+          else
+            ::TingYun::Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
+          end
+        rescue => e
+          ::TingYun::Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{e}")
+        end
+        data
+      end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def to_a
+      @data.to_a
+    end
+  end
+end

data/lib/ting_yun/frameworks/class_methods.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+require 'ting_yun/support/local_environment'
+require 'ting_yun/frameworks'
+
+
+module TingYun
+  module Frameworks
+    module ClassMethods
+      def instance
+        framework = TingYun::Agent.config[:framework]
+        if framework == :test
+          @instance ||= load_test_framework
+        else
+          @instance ||= load_framework_class(framework).new(local_env)
+        end
+
+      end
+
+      def load_test_framework
+        config = File.expand_path(File.join('..','..', 'test','config','tingyun.yml'), __FILE__)
+        require 'config/test'
+        TingYun::Frameworks::Test.new(local_env, config)
+      end
+
+
+      def load_framework_class(framework)
+        begin
+          require 'ting_yun/frameworks/' + framework.to_s
+        rescue LoadError
+          #to avoid error
+        end
+        TingYun::Frameworks.const_get(framework.to_s.capitalize)
+      end
+
+      def local_env
+        @local_env ||= TingYun::Support::LocalEnvironment.new
+      end
+
+      # clear out memoized Framework and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+    end
+  end
+end

data/lib/ting_yun/frameworks/external.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/ruby'
+
+module TingYun
+  module Frameworks
+    class External < TingYun::Frameworks::Ruby
+
+      def init_config(options={})
+        super
+      end
+
+    end
+  end
+end

data/lib/ting_yun/frameworks/instance_methods.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require 'ting_yun/configuration/manual_source'
+require 'ting_yun/configuration/yaml_source'
+require 'ting_yun/agent'
+require 'ting_yun/logger/agent_logger'
+require 'ting_yun/agent/agent'
+require 'ting_yun/frameworks/instrumentation'
+
+module TingYun
+  module Frameworks
+    module InstanceMethods
+
+      include ::TingYun::Frameworks::Instrumentation
+
+      # The env is the setting used to identify which section of the tingyun.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 nbs.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={})
+        env = determine_env(options)
+
+        configure_agent(env, options)
+
+        if ::TingYun::Agent.logger.is_startup_logger?
+          ::TingYun::Agent.logger = TingYun::Logger::AgentLogger.new(root, options.delete(:log))
+        end
+
+        environment_name = options.delete(:env) and self.env = environment_name
+
+        init_config(options)
+
+        TingYun::Agent.agent = TingYun::Agent::Agent.instance
+
+        if TingYun::Agent.config[:'nbs.agent_enabled'] && !TingYun::Agent.agent.started?
+          start_agent
+          install_instrumentation
+        else
+          LibraryDetection.detect!
+        end
+
+      end
+
+      def determine_env(options)
+        env = options[:env] || self.env
+        env = env.to_s
+
+        if @started_in_env && @started_in_env != env
+          TingYun::Agent.logger.error("Attempted to start agent in #{env.inspect} environment, but agent was already running in #{@started_in_env.inspect}",
+                             "The agent will continue running in #{@started_in_env.inspect}. To alter this, ensure the desired environment is set before the agent starts.")
+        else
+          TingYun::Agent.logger.info("Starting the Ting Yun agent in #{env.inspect} environment.",
+                            "To prevent agent startup add a TINGYUN_AGENT_ENABLED=false environment variable or modify the #{env.inspect} section of your tingyun.yml.")
+        end
+
+        env
+      end
+
+      def configure_agent(env, options)
+        # manual_source
+        TingYun::Agent.config.replace_or_add_config(TingYun::Configuration::ManualSource.new(options)) unless options.empty?
+
+        # yaml_source
+        config_file_path = @config_file_override || TingYun::Agent.config[:config_path]
+        TingYun::Agent.config.replace_or_add_config(TingYun::Configuration::YamlSource.new(config_file_path,env))
+      end
+
+      def start_agent
+        @started_in_env = self.env
+        TingYun::Agent.agent.start
+      end
+
+      def framework
+        Agent.config[:framework]
+      end
+
+      def [](key)
+        TingYun::Agent.config[key.to_sym]
+      end
+
+      def dispatcher
+        TingYun::Agent.config[:dispatcher]
+      end
+
+      def root
+        '.'
+      end
+
+
+    end
+  end
+end

data/lib/ting_yun/frameworks/instrumentation.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'ting_yun/support/library_detection'
+
+module TingYun
+  module Frameworks
+    # Contains methods that relate to adding and executing files that
+    # contain instrumentation for the Ruby Agent
+
+    module Instrumentation
+
+      # Signals the agent that it's time to actually load the
+      # instrumentation files. May be overridden by subclasses
+      def install_instrumentation
+        _install_instrumentation
+      end
+
+
+      def add_instrumentation(pattern)
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+
+      # 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 LoadError => e
+            TingYun::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+          end
+        end
+      end
+
+      def detect_dependencies
+        LibraryDetection.detect!
+      end
+
+      private
+
+      def _install_instrumentation
+        return if @instrumented
+
+        # instrumentation for the key code points inside rails for monitoring by TingYun.
+        # note this file is loaded only if the tingyun agent is enabled (through config/tingyun.yml)
+        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'instrumentation'))
+        @instrumentation_files << File.join(instrumentation_path, '*.rb')
+        @instrumentation_files << File.join(instrumentation_path, Agent.config[:framework].to_s, '*.rb')
+        @instrumentation_files.each { |pattern| load_instrumentation_files pattern }
+
+        TingYun::Support::LibraryDetection.detect!
+
+        ::TingYun::Agent.logger.info('Finished instrumentation')
+
+        @instrumented = true
+      end
+
+    end
+  end
+end

data/lib/ting_yun/frameworks/rails.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/ruby'
+
+module TingYun
+  module Frameworks
+    # noinspection ALL
+    class Rails < TingYun::Frameworks::Ruby
+
+      def env
+        @evn ||= RAILS_ENV.dup
+      end
+
+      def root
+        root = rails_root.to_s.empty? ? super : rails_root.to_s
+      end
+
+      # noinspection Rails3Deprecated,Rails3Deprecated
+      def rails_root
+        RAILS_ROOT if defined?(RAILS_ROOT)
+      end
+
+      def rails_config
+        if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+          ::Rails.configuration
+        else
+          @config
+        end
+      end
+
+      # In versions of Rails prior to 2.0, the rails config was only available to
+      # the init.rb, so it had to be passed on from there.  This is a best effort to
+      # find a config and use that.
+      def init_config(options = {})
+        @config = options[:config]
+        # Install the dependency detection,
+        if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+          rails_config.after_initialize do
+            # This will insure we load all the instrumentation as late as possible.  If the agent
+            # is not enabled, it will load a limited amount of instrumentation.
+            TingYun::Support::LibraryDetection.detect!
+          end
+        end
+
+        if !Agent.config[:'nbs.agent_enabled']
+          # Might not be running if it does not think mongrel, thin, passenger, etc
+          # is running, if it thinks it's a rake task, or if the nbs.agent_enabled is false.
+          ::TingYun::Agent.logger.info("TingYun Agent is unable to run.")
+        end
+      rescue => e
+        ::TingYun::Agent.logger.error("Failure during init_config for Rails. Is Rails required in a non-Rails app? Set TING_YUN_FRAMEWORK=ruby to avoid this message.",
+                                       "The Ruby agent will continue running, but Rails-specific features may be missing.",
+                                       e)
+      end
+
+      protected
+
+      def rails_vendor_root
+        File.join(root,'vendor','rails')
+      end
+    end
+  end
+end

data/lib/ting_yun/frameworks/rails3.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/rails'
+
+module TingYun
+  module Frameworks
+    class Rails3 < TingYun::Frameworks::Rails
+
+      def env
+        @env ||= ::Rails.env.to_s
+      end
+
+      def rails_root
+        ::Rails.root.to_s
+      end
+
+      def vendor_root
+        @vendor_root ||= File.join(root, 'vendor', 'rails')
+      end
+
+      def version
+        @rails_version ||= TingYun::Support::VersionNumber.new(::Rails::VERSION::STRING)
+      end
+    end
+  end
+end

data/lib/ting_yun/frameworks/rails4.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/rails3'
+
+module TingYun
+  module Frameworks
+    class Rails4 < TingYun::Frameworks::Rails3
+
+      def rails_gem_list
+        Bundler.rubygems.all_specs.map { |gem| "#{gem.name} (#{gem.version})" }
+      end
+    end
+  end
+end

data/lib/ting_yun/frameworks/ruby.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module TingYun
+  module Frameworks
+    class Ruby < TingYun::Frameworks::Framework
+      def env
+        @env ||= ENV['TINGYUN_ENV'] || ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
+
+      def root
+        @root ||= ENV['APP_ROOT'] || '.'
+      end
+
+      def init_config(options={})
+      end
+    end
+  end
+end

data/lib/ting_yun/frameworks/sinatra.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'ting_yun/frameworks/ruby'
+
+module TingYun
+  module Frameworks
+    class Sinatra < TingYun::Frameworks::Ruby;
+    end
+  end
+end

data/lib/ting_yun/frameworks.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+require 'ting_yun/frameworks/instance_methods'
+require 'ting_yun/frameworks/class_methods'
+
+
+module TingYun
+  module Frameworks
+
+    def self.framework
+      Framework.instance
+    end
+
+    def self.init_start(options={})
+      framework.init_plugin(options)
+    end
+
+    class Framework
+      include InstanceMethods
+      extend ClassMethods
+
+      protected
+
+      def initialize(local_env,config_file_override=nil)
+        @local_env = local_env
+        @started_in_env = nil
+        @config_file_override = config_file_override
+
+        @instrumentation_files = []
+      end
+    end
+  end
+end
+

data/lib/ting_yun/http/generic_request.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module TingYun
+  module Http
+    class GenericRequest
+
+    end
+  end
+end

data/lib/ting_yun/http/net_http_request.rb

@@ -0,0 +1,46 @@
+require 'ting_yun/http/generic_request'
+module TingYun
+  module Http
+    class NetHttpRequest < GenericRequest
+      def initialize(connection, request)
+        @connection = connection
+        @request = request
+      end
+
+      def type
+        'Net::HTTP'
+      end
+
+      def host
+        if hostname = self['host']
+          hostname.split(':').first
+        else
+          @connection.address
+        end
+      end
+
+      def method
+        @request.method
+      end
+
+      def [](key)
+        @request[key]
+      end
+
+      def []=(key, value)
+        @request[key] = value
+      end
+
+      def uri
+        case @request.path
+          when /^https?:\/\//
+            URI(@request.path)
+          else
+            scheme = @connection.use_ssl? ? 'https' : 'http'
+            URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
+        end
+      end
+    end
+  end
+end
+