mmtrix_rpm 1.0.0.1

data/lib/mmtrix/control/frameworks/rails.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/control/frameworks/ruby'
+module Mmtrix
+  class Control
+    module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails specific configuration, instrumentation, environment values,
+      # etc.
+      class Rails < Mmtrix::Control::Frameworks::Ruby
+
+        def env
+          @env ||= RAILS_ENV.dup
+        end
+
+        # Rails can return an empty string from this method, causing
+        # the agent not to start even when it is properly in a rails 3
+        # application, so we test the value to make sure it actually
+        # has contents, and bail to the parent class if it is empty.
+        def root
+          root = rails_root.to_s
+          if !root.empty?
+            root
+          else
+            super
+          end
+        end
+
+        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.
+              DependencyDetection.detect!
+            end
+          end
+          if !Agent.config[: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 agent_enabled is false.
+            ::Mmtrix::Agent.logger.info("Mmtrix Agent not running.")
+          else
+            install_developer_mode(rails_config) if Agent.config[:developer_mode]
+            install_browser_monitoring(rails_config)
+            install_agent_hooks(rails_config)
+          end
+        rescue => e
+          ::Mmtrix::Agent.logger.error("Failure during init_config for Rails. Is Rails required in a non-Rails app? Set MM_TRIX_FRAMEWORK=ruby to avoid this message.",
+                                         "The Ruby agent will continue running, but Rails-specific features may be missing.",
+                                         e)
+        end
+
+        def install_agent_hooks(config)
+          return if @agent_hooks_installed
+          @agent_hooks_installed = true
+          return if config.nil? || !config.respond_to?(:middleware)
+          begin
+            require 'mmtrix/rack/agent_hooks'
+            return unless Mmtrix::Rack::AgentHooks.needed?
+            config.middleware.use Mmtrix::Rack::AgentHooks
+            ::Mmtrix::Agent.logger.debug("Installed Mmtrix Agent Hooks middleware")
+          rescue => e
+            ::Mmtrix::Agent.logger.warn("Error installing Mmtrix Agent Hooks middleware", e)
+          end
+        end
+
+        def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
+          return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
+          begin
+            require 'mmtrix/rack/browser_monitoring'
+            config.middleware.use Mmtrix::Rack::BrowserMonitoring
+            ::Mmtrix::Agent.logger.debug("Installed Mmtrix Browser Monitoring middleware")
+          rescue => e
+            ::Mmtrix::Agent.logger.warn("Error installing Mmtrix Browser Monitoring middleware", e)
+          end
+        end
+
+        def install_developer_mode(rails_config)
+          return if @installed
+          @installed = true
+          if rails_config && rails_config.respond_to?(:middleware)
+            begin
+              require 'mmtrix/rack/developer_mode'
+              rails_config.middleware.use Mmtrix::Rack::DeveloperMode
+              ::Mmtrix::Agent.logger.info("Mmtrix Agent Developer Mode enabled.")
+              if env == "production"
+                ::Mmtrix::Agent.logger.warn("***Mmtrix Developer Mode is not intended to be enabled in production environments! We highly recommend setting developer_mode: false for the production environment in your mmtrix.yml.")
+              end
+            rescue => e
+              ::Mmtrix::Agent.logger.warn("Error installing Mmtrix Developer Mode", e)
+            end
+          elsif rails_config
+            ::Mmtrix::Agent.logger.warn("Developer mode not available for Rails versions prior to 2.2")
+          end
+        end
+
+        def rails_version
+          @rails_version ||= Mmtrix::VersionNumber.new(::Rails::VERSION::STRING)
+        end
+
+        protected
+
+        def rails_vendor_root
+          File.join(root,'vendor','rails')
+        end
+
+        def install_shim
+          super
+          require 'mmtrix/agent/instrumentation/controller_instrumentation'
+          if ActiveSupport.respond_to?(:on_load) # rails 3+
+            ActiveSupport.on_load(:action_controller) { include Mmtrix::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          else
+            ActionController::Base.class_eval { include Mmtrix::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/control/frameworks/rails3.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/control/frameworks/rails'
+require 'mmtrix/rack/error_collector'
+
+module Mmtrix
+  class Control
+    module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails 3.0+  specific configuration, instrumentation, environment values,
+      # etc. Many methods are inherited from the
+      # Mmtrix::Control::Frameworks::Rails class, where the two do
+      # not differ
+      class Rails3 < Mmtrix::Control::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 ||= Mmtrix::VersionNumber.new(::Rails::VERSION::STRING)
+        end
+
+        protected
+
+        def install_shim
+          super
+          ActiveSupport.on_load(:action_controller) do
+            include Mmtrix::Agent::Instrumentation::ControllerInstrumentation::Shim
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/control/frameworks/rails4.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/control/frameworks/rails3'
+require 'mmtrix/rack/error_collector'
+module Mmtrix
+  class Control
+    module Frameworks
+      class Rails4 < Mmtrix::Control::Frameworks::Rails3
+        def rails_gem_list
+          Bundler.rubygems.all_specs.map do |gem|
+            "#{gem.name} (#{gem.version})"
+          end
+        end
+
+        def append_plugin_list
+          # Rails 4 does not allow plugins
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/control/frameworks/ruby.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  class Control
+    module Frameworks
+      # A control used when no framework is detected - the default.
+      class Ruby < Mmtrix::Control
+        def env
+          @env ||= ENV['MM_TRIX_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
+end

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

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/control/frameworks/ruby'
+module Mmtrix
+  class Control
+    module Frameworks
+      # Contains basic control logic for Sinatra
+      class Sinatra < Mmtrix::Control::Frameworks::Ruby
+      end
+    end
+  end
+end

data/lib/mmtrix/control/frameworks.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  class Control
+    # Contains subclasses of Mmtrix::Control that are used when
+    # starting the agent within an application. Framework-specific
+    # logic should be included here, as documented within the Control
+    # abstract parent class
+    module Frameworks
+    end
+  end
+end

data/lib/mmtrix/control/instance_methods.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/agent/null_logger'
+require 'mmtrix/agent/memory_logger'
+require 'mmtrix/agent/agent_logger'
+
+module Mmtrix
+  class Control
+
+    # Contains methods that relate to the runtime usage of the control
+    # object. Note that these are subject to override in the
+    # Mmtrix::Control::Framework classes that are actually instantiated
+    module InstanceMethods
+      # The env is the setting used to identify which section of the mmtrix.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={})
+        env = determine_env(options)
+
+        configure_agent(env, options)
+
+        # Be sure to only create once! RUBY-1020
+        if ::Mmtrix::Agent.logger.is_startup_logger?
+          ::Mmtrix::Agent.logger = Mmtrix::Agent::AgentLogger.new(root, options.delete(:log))
+        end
+
+        # Merge the stringified options into the config as overrides:
+        environment_name = options.delete(:env) and self.env = environment_name
+
+        Mmtrix::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, Mmtrix::Agent::MethodTracer::ClassMethods
+        Module.send :include, Mmtrix::Agent::MethodTracer
+        init_config(options)
+        Mmtrix::Agent.agent = Mmtrix::Agent::Agent.instance
+        if Agent.config[:agent_enabled] && !Mmtrix::Agent.instance.started?
+          start_agent
+          install_instrumentation
+        elsif !Agent.config[:agent_enabled]
+          install_shim
+        else
+          DependencyDetection.detect!
+        end
+      end
+
+      def determine_env(options)
+        env = options[:env] || self.env
+        env = env.to_s
+
+        if @started_in_env && @started_in_env != env
+          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
+          Agent.logger.info("Starting the Mmtrix agent in #{env.inspect} environment.",
+                            "To prevent agent startup add a MMTRIX_AGENT_ENABLED=false environment variable or modify the #{env.inspect} section of your mmtrix.yml.")
+        end
+
+        env
+      end
+
+      def configure_agent(env, options)
+        manual = Agent::Configuration::ManualSource.new(options)
+        Agent.config.replace_or_add_config(manual)
+
+        config_file_path = @config_file_override || Agent.config[:config_path]
+        Agent.config.replace_or_add_config(Agent::Configuration::YamlSource.new(config_file_path, env))
+
+        if Agent.config[:high_security]
+          Agent.logger.info("Installing high security configuration based on local configuration")
+          Agent.config.replace_or_add_config(Agent::Configuration::HighSecuritySource.new(Agent.config))
+        end
+      end
+
+      # Install the real agent into the Agent module, and issue the start command.
+      def start_agent
+        @started_in_env = self.env
+        Mmtrix::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)
+        Mmtrix::Agent.config[key.to_sym]
+      end
+
+      def settings
+        Mmtrix::Agent.config.to_collector_hash
+      end
+
+      def dispatcher
+        Mmtrix::Agent.config[:dispatcher]
+      end
+
+      # Delegates to the class method mmtrix_root, implemented by
+      # each subclass
+      def mmtrix_root
+        self.class.mmtrix_root
+      end
+
+      protected
+
+      def initialize(local_env, config_file_override=nil)
+        @local_env = local_env
+        @started_in_env = nil
+
+        @instrumented = nil
+        @instrumentation_files = []
+
+        @config_file_override = config_file_override
+      end
+
+      def root
+        '.'
+      end
+
+    end
+    include InstanceMethods
+  end
+end

data/lib/mmtrix/control/instrumentation.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  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
+            ::Mmtrix::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+          end
+        end
+      end
+
+      def install_shim
+        # implemented only in subclasses
+      end
+
+      # Add instrumentation.  Don't call this directly.  Use Mmtrix::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
+
+      private
+
+      def _install_instrumentation
+        return if @instrumented
+
+        @instrumented = true
+
+        # Instrumentation for the key code points inside rails for monitoring by Mmtrix.
+        # note this file is loaded only if the mmtrix agent is enabled (through config/mmtrix.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!
+        ::Mmtrix::Agent.logger.info "Finished instrumentation"
+      end
+    end
+    include Instrumentation
+  end
+end

data/lib/mmtrix/control/server_methods.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  class Control
+
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    # 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 ||= Mmtrix::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port])
+      end
+
+      def server_from_host(hostname=nil)
+        Mmtrix::Control::Server.new(hostname || Agent.config[:host], Agent.config[:port])
+      end
+    end
+
+    include ServerMethods
+  end
+end

data/lib/mmtrix/control.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'yaml'
+require 'conditional_vendored_dependency_detection'
+require 'mmtrix/local_environment'
+require 'mmtrix/language_support'
+require 'mmtrix/helper'
+require 'mmtrix/json_wrapper'
+
+require 'singleton'
+require 'erb'
+require 'socket'
+require 'net/https'
+require 'logger'
+require 'mmtrix/control/frameworks'
+require 'mmtrix/control/server_methods'
+require 'mmtrix/control/instrumentation'
+require 'mmtrix/control/class_methods'
+require 'mmtrix/control/instance_methods'
+
+require 'mmtrix/agent'
+require 'mmtrix/delayed_job_injection'
+
+module Mmtrix
+
+  # The Control is a singleton responsible for the startup and
+  # initialization sequence.  The initializer uses a LocalEnvironment to
+  # detect the framework and instantiates the framework specific
+  # subclass.
+  #
+  # The Control also implements some of the public API for the agent.
+  #
+  class Control
+    # done in a subfile for load order purposes
+    # extend ClassMethods
+    # include InstanceMethods
+    # include Configuration
+    # include ServerMethods
+    # include Instrumentation
+  end
+end

data/lib/mmtrix/delayed_job_injection.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end