mmtrix_rpm 1.0.0.1

data/lib/mmtrix/build.rb

@@ -0,0 +1,2 @@
+# GITSHA: ba763889bb391bf7a4f53ba1734b4b766afba048
+module Mmtrix; module VERSION; BUILD='1'; end; end

data/lib/mmtrix/cli/command.rb

@@ -0,0 +1,91 @@
+# 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 'optparse'
+
+# Run the command given by the first argument.  Right
+# now all we have is deployments. We hope to have other
+# kinds of events here later.
+$LOAD_PATH << "#{File.dirname(__FILE__)}/.."
+module Mmtrix
+  module Cli
+    class Command
+      attr_accessor :leftover
+      # Capture a failure to execute the command.
+      class CommandFailure < StandardError
+        attr_reader :options
+        def initialize message, opt_parser=nil
+          super message
+          @options = opt_parser
+        end
+      end
+
+      def info(message)
+        STDOUT.puts message
+      end
+
+      def err(message)
+        STDERR.puts message
+      end
+
+      def initialize(command_line_args)
+        if Hash === command_line_args
+          # command line args is an options hash
+          command_line_args.each do | key, value |
+            instance_variable_set "@#{key}", value.to_s if value
+          end
+        else
+          # parse command line args.  Throw an exception on a bad arg.
+          @options = options do | opts |
+            opts.on("-h", "Show this help") {  raise CommandFailure, opts.to_s }
+          end
+          @leftover = @options.parse(command_line_args)
+        end
+      rescue OptionParser::ParseError => e
+        raise CommandFailure.new(e.message, @options)
+      end
+
+      @commands = []
+      def self.inherited(subclass)
+        @commands << subclass
+      end
+
+      cmds = File.expand_path(File.join(File.dirname(__FILE__), 'commands', '*.rb'))
+      Dir[cmds].each { |command| require command }
+
+      def self.run
+
+        @command_names = @commands.map{ |c| c.command }
+
+        extra = []
+        options = ARGV.options do |opts|
+          script_name = File.basename($0)
+          if script_name =~ /mmtrix_cmd$/
+            $stdout.puts "warning: the 'mmtrix_cmd' script has been renamed 'mmtrix'"
+            script_name = 'mmtrix'
+          end
+          opts.banner = "Usage: #{script_name} [ #{ @command_names.join(" | ")} ] [options]"
+          opts.separator "use '#{script_name} <command> -h' to see detailed command options"
+          opts
+        end
+        extra = options.order!
+        command = extra.shift
+        # just make it a little easier on them
+        command = 'deployments' if command =~ /deploy/
+          if command.nil?
+            STDERR.puts options
+          elsif !@command_names.include?(command)
+            STDERR.puts "Unrecognized command: #{command}"
+            STDERR.puts options
+          else
+            command_class = @commands.find{ |c| c.command == command}
+            command_class.new(extra).run
+          end
+      rescue OptionParser::InvalidOption => e
+        raise Mmtrix::Cli::Command::CommandFailure, e.message
+      end
+    end
+
+  end
+end

data/lib/mmtrix/cli/commands/deployments.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# This is a class for executing commands related to deployment
+# events.  It runs without loading the rails environment
+
+require 'yaml'
+require 'net/http'
+require 'rexml/document'
+require 'mmtrix/agent/hostname'
+
+# We need to use the Control object but we don't want to load
+# the rails/merb environment.  The defined? clause is so that
+# it won't load it twice, something it does when run inside a test
+require 'mmtrix/control' unless defined? Mmtrix::Control
+
+class Mmtrix::Cli::Deployments < Mmtrix::Cli::Command
+  attr_reader :control
+  def self.command; "deployments"; end
+
+  # Initialize the deployment uploader with command line args.
+  # Use -h to see options.
+  # When command_line_args is a hash, we are invoking directly and
+  # it's treated as an options with optional string values for
+  # :user, :description, :appname, :revision, :environment,
+  # :license_key, and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  #
+  def initialize command_line_args
+    @control = Mmtrix::Control.instance
+    super(command_line_args)
+    @description ||= @leftover && @leftover.join(" ")
+    @user ||= ENV['USER']
+    control.env = @environment if @environment
+
+    load_yaml_from_env(control.env)
+    @appname ||= Mmtrix::Agent.config.app_names[0] || control.env || 'development'
+    @license_key ||= Mmtrix::Agent.config[:license_key]
+
+    setup_logging(control.env)
+  end
+
+  def load_yaml_from_env(env)
+    yaml = Mmtrix::Agent::Configuration::YamlSource.new(Mmtrix::Agent.config[:config_path], env)
+    if yaml.failed?
+      messages = yaml.failures.flatten.map(&:to_s).join("\n")
+      raise Mmtrix::Cli::Command::CommandFailure.new("Error in loading mmtrix.yml.\n#{messages}")
+    end
+
+    Mmtrix::Agent.config.replace_or_add_config(yaml)
+  end
+
+  def setup_logging(env)
+    Mmtrix::Agent.logger = Mmtrix::Agent::AgentLogger.new
+    Mmtrix::Agent.logger.info("Running Capistrano from '#{env}' environment for application '#{@appname}'")
+  end
+
+  # Run the Deployment upload in Mmtrix via Active Resource.
+  # Will possibly print errors and exit the VM
+  def run
+    begin
+      @description = nil if @description && @description.strip.empty?
+      create_params = {}
+      {
+            :application_id => @appname,
+            :host => Mmtrix::Agent::Hostname.get,
+            :description => @description,
+            :user => @user,
+            :revision => @revision,
+            :changelog => @changelog
+      }.each do |k, v|
+        create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
+      end
+      http = ::Mmtrix::Agent::MmtrixService.new(nil, control.api_server).http_connection
+
+      uri = "/deployments.xml"
+
+      if @license_key.nil? || @license_key.empty?
+        raise "license_key was not set in mmtrix.yml for #{control.env}"
+      end
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => @license_key})
+      request.content_type = "application/octet-stream"
+
+      request.set_form_data(create_params)
+
+      response = http.request(request)
+
+      if response.is_a? Net::HTTPSuccess
+        info "Recorded deployment to '#{@appname}' (#{@description || Time.now })"
+      else
+        err_string = REXML::Document.new(response.body).elements['errors/error'].map(&:to_s).join("; ") rescue  response.message
+        raise Mmtrix::Cli::Command::CommandFailure, "Deployment not recorded: #{err_string}"
+      end
+    rescue SystemCallError, SocketError => e
+      # These include Errno connection errors
+      err_string = "Transient error attempting to connect to #{control.api_server} (#{e})"
+      raise Mmtrix::Cli::Command::CommandFailure.new(err_string)
+    rescue Mmtrix::Cli::Command::CommandFailure
+      raise
+    rescue => e
+      err "Unexpected error attempting to connect to #{control.api_server}"
+      info "#{e}: #{e.backtrace.join("\n   ")}"
+      raise Mmtrix::Cli::Command::CommandFailure.new(e.to_s)
+    end
+  end
+
+  private
+
+  def options
+    OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |o|
+      o.separator "OPTIONS:"
+      o.on("-a", "--appname=NAME", String,
+             "Set the application name.",
+             "Default is app_name setting in mmtrix.yml") { | e | @appname = e }
+      o.on("-e", "--environment=name", String,
+               "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
+               "currently: #{control.env}") { | e | @environment = e }
+      o.on("-u", "--user=USER", String,
+             "Specify the user deploying, for information only",
+             "Default: #{@user || '<none>'}") { | u | @user = u }
+      o.on("-r", "--revision=REV", String,
+             "Specify the revision being deployed") { | r | @revision = r }
+      o.on("-l", "--license-key=KEY", String,
+             "Specify the license key of the account for the app being deployed") { | l | @license_key = l }
+      o.on("-c", "--changes",
+             "Read in a change log from the standard input") { @changelog = STDIN.read }
+      yield o if block_given?
+    end
+  end
+
+
+end

data/lib/mmtrix/cli/commands/install.rb

@@ -0,0 +1,84 @@
+# 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 'fileutils'
+require 'mmtrix/version'
+require 'erb'
+
+class Mmtrix::Cli::Install < Mmtrix::Cli::Command
+
+  NO_LICENSE_KEY = "<PASTE LICENSE KEY HERE>"
+
+  def self.command; "install"; end
+
+  # Use -h to see options.
+  # When command_line_args is a hash, we are invoking directly and
+  # it's treated as an options with optional string values for
+  # :user, :description, :appname, :revision, :environment,
+  # and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  #
+  attr_reader :dest_dir, :license_key, :generated_for_user, :quiet, :src_file, :app_name
+  def initialize command_line_args={}
+    super command_line_args
+    if !@dest_dir
+      # Install a mmtrix.yml file into the local config directory.
+      if File.directory? "config"
+        @dest_dir = "config"
+      else
+        @dest_dir = "."
+      end
+    end
+    @license_key ||= NO_LICENSE_KEY
+    @app_name ||= @leftover.join(" ")
+    @agent_version = Mmtrix::VERSION::STRING
+    raise CommandFailure.new("Application name required.", @options) unless @app_name && @app_name.size > 0
+  end
+
+  def run
+    dest_file = File.expand_path(@dest_dir + "/mmtrix.yml")
+    if File.exist?(dest_file)
+      raise Mmtrix::Cli::Command::CommandFailure, "mmtrix.yml file already exists.  Move it out of the way."
+    end
+    File.open(dest_file, 'w') { | out | out.puts(content) }
+
+    puts <<-EOF unless quiet
+
+Installed a default configuration file at
+#{dest_file}.
+    EOF
+    puts <<-EOF unless quiet || @license_key != NO_LICENSE_KEY
+
+To monitor your application in production mode, sign up for an account
+at www.mmtrix.com, and replace the mmtrix.yml file with the one
+you receive upon registration.
+    EOF
+    puts <<-EOF unless quiet
+
+Visit support.mmtrix.com if you are experiencing installation issues.
+    EOF
+
+  end
+
+  def content
+    @src_file ||= File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","..","mmtrix.yml"))
+    template = File.read(@src_file)
+    ERB.new(template).result(binding)
+  end
+
+  private
+
+  def options
+    OptionParser.new "Usage: #{$0} #{self.class.command} [ OPTIONS] 'application name'", 40 do |o|
+      o.on("-l", "--license_key=NAME", String,
+             "Use the given license key") { | e | @license_key = e }
+      o.on("-d", "--destdir=name", String,
+               "Write the mmtrix.yml to the given directory, default is '.'") { | e | @dest_dir = e }
+      yield o if block_given?
+    end
+  end
+
+
+end

data/lib/mmtrix/coerce.rb

@@ -0,0 +1,70 @@
+# 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
+  # We really don't want to send bad values to the collector, and it doesn't
+  # accept types like Rational that have occasionally slipped into our data.
+  #
+  # These methods are intended to safely coerce things into the form we want,
+  # to provide documentation of expected types on to_collector_array methods,
+  # and to log failures if totally invalid data gets into outgoing data
+  module Coerce
+    module_function
+
+    def int(value, context=nil)
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      0
+    end
+
+    def int_or_nil(value, context=nil)
+      return nil if value.nil?
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      nil
+    end
+
+    def float(value, context=nil)
+      result = Float(value)
+      raise "Value #{result.inspect} is not finite." unless result.finite?
+      result
+    rescue => error
+      log_failure(value, Float, context, error)
+      0.0
+    end
+
+    def string(value, context=nil)
+      return value if value.nil?
+      String(value)
+    rescue => error
+      log_failure(value.class, String, context, error)
+      ""
+    end
+
+    def scalar(val)
+      case val
+      when String, Integer, TrueClass, FalseClass, NilClass
+        val
+      when Float
+        if val.finite?
+          val
+        else
+          nil
+        end
+      when Symbol
+        val.to_s
+      else
+        "#<#{val.class.to_s}>"
+      end
+    end
+
+    def log_failure(value, type, context, error)
+      msg = "Unable to convert '#{value}' to #{type}"
+      msg += " in context '#{context}'" if context
+      Mmtrix::Agent.logger.warn(msg, error)
+    end
+  end
+end

data/lib/mmtrix/collection_helper.rb

@@ -0,0 +1,79 @@
+# 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 CollectionHelper
+  DEFAULT_TRUNCATION_SIZE=16 * 1024
+  DEFAULT_ARRAY_TRUNCATION_SIZE=128
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Hash
+        # optimize for empty hash since that is often what this is called with.
+        return params if params.empty?
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
+        end
+        new_params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Array
+        params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
+    else
+      truncate(flatten(params))
+    end
+  end
+
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+
+  def strip_nr_from_backtrace(backtrace)
+    if backtrace && !Agent.config[:disable_backtrace_cleanup]
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      backtrace = backtrace.map(&:to_s)
+      backtrace = backtrace.reject do |line|
+        line.include?(Mmtrix::Control.mmtrix_root) or
+        line =~ /^mmtrix_rpm\s/
+      end
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(mmtrix|trace)/, "")}
+    end
+    backtrace
+  end
+
+  private
+
+  # Convert any kind of object to a short string.
+  def flatten(object)
+    case object
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
+    end
+  end
+  def truncate(string, len=DEFAULT_TRUNCATION_SIZE)
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
+      real_string = flatten(string)
+      if real_string.size > len
+        real_string = real_string.slice(0...len)
+        real_string << "..."
+      end
+      real_string
+    else
+      truncate(flatten(string), len)
+    end
+  end
+  end
+end

data/lib/mmtrix/control/class_methods.rb

@@ -0,0 +1,62 @@
+# 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
+    # class-level methods for lazy creation of Mmtrix::Control and
+    # Mmtrix::LocalEnvironment instances.
+    module ClassMethods
+      # Access the Control singleton, lazy initialized.  Default will instantiate a new
+      # instance or pass false to defer
+      def instance(create=true)
+        @instance ||= create && new_instance
+      end
+
+      # clear out memoized Control and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+
+      # Access the LocalEnvironment singleton, lazy initialized
+      def local_env
+        @local_env ||= Mmtrix::LocalEnvironment.new
+      end
+
+      # Create the concrete class for environment specific behavior
+      def new_instance
+        if Agent.config[:framework] == :test
+          load_test_framework
+        else
+          load_framework_class(Agent.config[:framework]).new(local_env)
+        end
+      end
+
+      # nb this does not 'load test' the framework, it loads the 'test framework'
+      def load_test_framework
+        config = File.expand_path(File.join('..','..','..','..', "test","config","mmtrix.yml"), __FILE__)
+        require "config/test_control"
+        Mmtrix::Control::Frameworks::Test.new(local_env, config)
+      end
+
+      # Loads the specified framework class from the
+      # Mmtrix::Control::Frameworks module
+      def load_framework_class(framework)
+        begin
+          require "mmtrix/control/frameworks/#{framework}"
+        rescue LoadError
+          # maybe it is already loaded by some external system
+          # i.e. rpm_contrib or user extensions?
+        end
+        Mmtrix::Control::Frameworks.const_get(framework.to_s.capitalize)
+      end
+
+      # The root directory for the plugin or gem
+      def mmtrix_root
+        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
+      end
+    end
+    extend ClassMethods
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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
+      # This is the control used when starting up in the context of
+      # The Mmtrix Infrastructure Agent.  We want to call this
+      # out specifically because in this context we are not monitoring
+      # the running process, but actually external things.
+      class External < Mmtrix::Control::Frameworks::Ruby
+        def init_config(options={})
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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
+      # Includes limited support for Merb
+      class Merb < Mmtrix::Control
+
+        def env
+          @env ||= ::Merb.env
+        end
+        def root
+          ::Merb.root
+        end
+
+        def init_config options={}
+          ::Merb::Plugins.add_rakefiles File.join(mmtrix_root,"lib/tasks/all.rb")
+
+          # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+          ::Merb::Plugins.config[:mmtrix] = {
+            :config => self
+          }
+        end
+      end
+    end
+  end
+end