diff --git a/lib/puppet/agent.rb b/lib/puppet/agent.rb
index f0071785b..c9f600418 100644
--- a/lib/puppet/agent.rb
+++ b/lib/puppet/agent.rb
@@ -1,140 +1,138 @@
 require 'sync'
 require 'puppet/external/event-loop'
 require 'puppet/application'
 
 # A general class for triggering a run of another
 # class.
 class Puppet::Agent
   require 'puppet/agent/locker'
   include Puppet::Agent::Locker
 
   require 'puppet/agent/disabler'
   include Puppet::Agent::Disabler
 
   attr_reader :client_class, :client, :splayed
   attr_accessor :should_fork
 
   # Just so we can specify that we are "the" instance.
   def initialize(client_class)
     @splayed = false
 
     @client_class = client_class
   end
 
   def lockfile_path
     client_class.lockfile_path
   end
 
   def needing_restart?
     Puppet::Application.restart_requested?
   end
 
   # Perform a run with our client.
   def run(*args)
     if running?
       Puppet.notice "Run of #{client_class} already in progress; skipping"
       return
     end
     if disabled?
       Puppet.notice "Skipping run of #{client_class}; administratively disabled: #{disable_message}"
       return
     end
     result = nil
     block_run = Puppet::Application.controlled_run do
       splay
       result = run_in_fork(should_fork) do
         with_client do |client|
           begin
             sync.synchronize { lock { client.run(*args) } }
           rescue SystemExit,NoMemoryError
             raise
           rescue Exception => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Could not run #{client_class}: #{detail}"
+            Puppet.log_exception(detail, "Could not run #{client_class}: #{detail}")
           end
         end
       end
       true
     end
     Puppet.notice "Shutdown/restart in progress (#{Puppet::Application.run_status.inspect}); skipping run" unless block_run
     result
   end
 
   def stopping?
     Puppet::Application.stop_requested?
   end
 
   # Have we splayed already?
   def splayed?
     splayed
   end
 
   # Sleep when splay is enabled; else just return.
   def splay
     return unless Puppet[:splay]
     return if splayed?
 
     time = rand(Integer(Puppet[:splaylimit]) + 1)
     Puppet.info "Sleeping for #{time} seconds (splay is enabled)"
     sleep(time)
     @splayed = true
   end
 
   # Start listening for events.  We're pretty much just listening for
   # timer events here.
   def start
     # Create our timer.  Puppet will handle observing it and such.
     timer = EventLoop::Timer.new(:interval => Puppet[:runinterval], :tolerance => 1, :start? => true) do
       run
     end
 
     # Run once before we start following the timer
     timer.sound_alarm
   end
 
   def sync
     @sync ||= Sync.new
   end
 
   def run_in_fork(forking = true)
     return yield unless forking or Puppet.features.windows?
 
     child_pid = Kernel.fork do
       $0 = "puppet agent: applying configuration"
       begin
         exit(yield)
       rescue SystemExit
         exit(-1)
       rescue NoMemoryError
         exit(-2)
       end
     end
     exit_code = Process.waitpid2(child_pid)
     case exit_code[1].exitstatus
     when -1
       raise SystemExit
     when -2
       raise NoMemoryError
     end
     exit_code[1].exitstatus
   end
 
   private
 
   # Create and yield a client instance, keeping a reference
   # to it during the yield.
   def with_client
     begin
       @client = client_class.new
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not create instance of #{client_class}: #{detail}"
+      Puppet.log_exception(detail, "Could not create instance of #{client_class}: #{detail}")
       return
     end
     yield @client
   ensure
     @client = nil
   end
 end
diff --git a/lib/puppet/application.rb b/lib/puppet/application.rb
index c940d06c2..3eb68e574 100644
--- a/lib/puppet/application.rb
+++ b/lib/puppet/application.rb
@@ -1,418 +1,417 @@
 require 'optparse'
 require 'puppet/util/plugins'
 
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
 # * setting up logs
 # * choosing what to run
 # * representing execution status
 #
 # === Usage
 # An application is a subclass of Puppet::Application.
 #
 # For legacy compatibility,
 #      Puppet::Application[:example].run
 # is equivalent to
 #      Puppet::Application::Example.new.run
 #
 #
 # class Puppet::Application::Example << Puppet::Application
 #
 #     def preinit
 #         # perform some pre initialization
 #         @all = false
 #     end
 #
 #     # run_command is called to actually run the specified command
 #     def run_command
 #         send Puppet::Util::CommandLine.new.args.shift
 #     end
 #
 #     # option uses metaprogramming to create a method
 #     # and also tells the option parser how to invoke that method
 #     option("--arg ARGUMENT") do |v|
 #         @args << v
 #     end
 #
 #     option("--debug", "-d") do |v|
 #         @debug = v
 #     end
 #
 #     option("--all", "-a:) do |v|
 #         @all = v
 #     end
 #
 #     def handle_unknown(opt,arg)
 #         # last chance to manage an option
 #         ...
 #         # let's say to the framework we finally handle this option
 #         true
 #     end
 #
 #     def read
 #         # read action
 #     end
 #
 #     def write
 #         # writeaction
 #     end
 #
 # end
 #
 # === Preinit
 # The preinit block is the first code to be called in your application, before option parsing,
 # setup or command execution.
 #
 # === Options
 # Puppet::Application uses +OptionParser+ to manage the application options.
 # Options are defined with the +option+ method to which are passed various
 # arguments, including the long option, the short option, a description...
 # Refer to +OptionParser+ documentation for the exact format.
 # * If the option method is given a block, this one will be called whenever
 # the option is encountered in the command-line argument.
 # * If the option method has no block, a default functionnality will be used, that
 # stores the argument (or true/false if the option doesn't require an argument) in
 # the global (to the application) options array.
 # * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
 #  * if +unknown+ was used with a block, it will be called with the option name and argument
 #  * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
 #    a default behavior
 #
 # --help is managed directly by the Puppet::Application class, but can be overriden.
 #
 # === Setup
 # Applications can use the setup block to perform any initialization.
 # The defaul +setup+ behaviour is to: read Puppet configuration and manage log level and destination
 #
 # === What and how to run
 # If the +dispatch+ block is defined it is called. This block should return the name of the registered command
 # to be run.
 # If it doesn't exist, it defaults to execute the +main+ command if defined.
 #
 # === Execution state
 # The class attributes/methods of Puppet::Application serve as a global place to set and query the execution
 # status of the application: stopping, restarting, etc.  The setting of the application status does not directly
 # aftect its running status; it's assumed that the various components within the application will consult these
 # settings appropriately and affect their own processing accordingly.  Control operations (signal handlers and
 # the like) should set the status appropriately to indicate to the overall system that it's the process of
 # stopping or restarting (or just running as usual).
 #
 # So, if something in your application needs to stop the process, for some reason, you might consider:
 #
 #  def stop_me!
 #      # indicate that we're stopping
 #      Puppet::Application.stop!
 #      # ...do stuff...
 #  end
 #
 # And, if you have some component that involves a long-running process, you might want to consider:
 #
 #  def my_long_process(giant_list_to_munge)
 #      giant_list_to_munge.collect do |member|
 #          # bail if we're stopping
 #          return if Puppet::Application.stop_requested?
 #          process_member(member)
 #      end
 #  end
 module Puppet
 class Application
   require 'puppet/util'
   include Puppet::Util
 
   DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
 
   class << self
     include Puppet::Util
 
     attr_accessor :run_status
 
     def clear!
       self.run_status = nil
     end
 
     def stop!
       self.run_status = :stop_requested
     end
 
     def restart!
       self.run_status = :restart_requested
     end
 
     # Indicates that Puppet::Application.restart! has been invoked and components should
     # do what is necessary to facilitate a restart.
     def restart_requested?
       :restart_requested == run_status
     end
 
     # Indicates that Puppet::Application.stop! has been invoked and components should do what is necessary
     # for a clean stop.
     def stop_requested?
       :stop_requested == run_status
     end
 
     # Indicates that one of stop! or start! was invoked on Puppet::Application, and some kind of process
     # shutdown/short-circuit may be necessary.
     def interrupted?
       [:restart_requested, :stop_requested].include? run_status
     end
 
     # Indicates that Puppet::Application believes that it's in usual running run_mode (no stop/restart request
     # currently active).
     def clear?
       run_status.nil?
     end
 
     # Only executes the given block if the run status of Puppet::Application is clear (no restarts, stops,
     # etc. requested).
     # Upon block execution, checks the run status again; if a restart has been requested during the block's
     # execution, then controlled_run will send a new HUP signal to the current process.
     # Thus, long-running background processes can potentially finish their work before a restart.
     def controlled_run(&block)
       return unless clear?
       result = block.call
       Process.kill(:HUP, $PID) if restart_requested?
       result
     end
 
     def should_parse_config
       @parse_config = true
     end
 
     def should_not_parse_config
       @parse_config = false
     end
 
     def should_parse_config?
       @parse_config = true if ! defined?(@parse_config)
       @parse_config
     end
 
     # used to declare code that handle an option
     def option(*options, &block)
       long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
       fname = symbolize("handle_#{long}")
       if (block_given?)
         define_method(fname, &block)
       else
         define_method(fname) do |value|
           self.options["#{long}".to_sym] = value
         end
       end
       self.option_parser_commands << [options, fname]
     end
 
     def banner(banner = nil)
       @banner ||= banner
     end
 
     def option_parser_commands
       @option_parser_commands ||= (
         superclass.respond_to?(:option_parser_commands) ? superclass.option_parser_commands.dup : []
       )
       @option_parser_commands
     end
 
     def find(name)
       klass = name.to_s.capitalize
 
       begin
         require ::File.join('puppet', 'application', name.to_s.downcase)
       rescue LoadError => e
         puts "Unable to find application '#{name}'.  #{e}"
         Kernel::exit(1)
       end
 
       self.const_get(klass)
     end
 
     def [](name)
       find(name).new
     end
 
     # Sets or gets the run_mode name. Sets the run_mode name if a mode_name is
     # passed. Otherwise, gets the run_mode or a default run_mode
     #
     def run_mode( mode_name = nil)
       return @run_mode if @run_mode and not mode_name
 
       require 'puppet/util/run_mode'
       @run_mode = Puppet::Util::RunMode[ mode_name || :user ]
     end
   end
 
   attr_reader :options, :command_line
 
   # Every app responds to --version
   option("--version", "-V") do |arg|
     puts "#{Puppet.version}"
     exit
   end
 
   # Every app responds to --help
   option("--help", "-h") do |v|
     puts help
     exit
   end
 
   def should_parse_config?
     self.class.should_parse_config?
   end
 
   # override to execute code before running anything else
   def preinit
   end
 
   def initialize(command_line = nil)
 
     require 'puppet/util/command_line'
     @command_line = command_line || Puppet::Util::CommandLine.new
     set_run_mode self.class.run_mode
     @options = {}
 
     require 'puppet'
     require 'puppet/util/instrumentation'
     Puppet::Util::Instrumentation.init
   end
 
   # WARNING: This is a totally scary, frightening, and nasty internal API.  We
   # strongly advise that you do not use this, and if you insist, we will
   # politely allow you to keep both pieces of your broken code.
   #
   # We plan to provide a supported, long-term API to deliver this in a way
   # that you can use.  Please make sure that you let us know if you do require
   # this, and this message is still present in the code. --daniel 2011-02-03
   def set_run_mode(mode)
     @run_mode = mode
     $puppet_application_mode = @run_mode
     $puppet_application_name = name
 
     if Puppet.respond_to? :settings
       # This is to reduce the amount of confusion in rspec
       # because it might have loaded defaults.rb before the globals were set
       # and thus have the wrong defaults for the current application
       Puppet.settings.set_value(:confdir, Puppet.run_mode.conf_dir, :mutable_defaults)
       Puppet.settings.set_value(:vardir, Puppet.run_mode.var_dir, :mutable_defaults)
       Puppet.settings.set_value(:name, Puppet.application_name.to_s, :mutable_defaults)
       Puppet.settings.set_value(:logdir, Puppet.run_mode.logopts, :mutable_defaults)
       Puppet.settings.set_value(:rundir, Puppet.run_mode.run_dir, :mutable_defaults)
       Puppet.settings.set_value(:run_mode, Puppet.run_mode.name.to_s, :mutable_defaults)
     end
   end
 
   # This is the main application entry point
   def run
     exit_on_fail("initialize")                                   { hook('preinit')       { preinit } }
     exit_on_fail("parse options")                                { hook('parse_options') { parse_options } }
     exit_on_fail("parse configuration file")                     { Puppet.settings.parse } if should_parse_config?
     exit_on_fail("prepare for execution")                        { hook('setup')         { setup } }
     exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
     exit_on_fail("run")                                          { hook('run_command')   { run_command } }
   end
 
   def main
     raise NotImplementedError, "No valid command or main"
   end
 
   def run_command
     main
   end
 
   def setup
     # Handle the logging settings
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def configure_indirector_routes
     route_file = Puppet[:route_file]
     if ::File.exists?(route_file)
       routes = YAML.load_file(route_file)
       application_routes = routes[name.to_s]
       Puppet::Indirector.configure_routes(application_routes) if application_routes
     end
   end
 
   def parse_options
     # Create an option parser
     option_parser = OptionParser.new(self.class.banner)
 
     # Add all global options to it.
     Puppet.settings.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
         handlearg(option[0], arg)
       end
     end
 
     # Add options that are local to this application, which were
     # created using the "option()" metaprogramming method.  If there
     # are any conflicts, this application's options will be favored.
     self.class.option_parser_commands.each do |options, fname|
       option_parser.on(*options) do |value|
         # Call the method that "option()" created.
         self.send(fname, value)
       end
     end
 
     # Scan command line.  We just hand any exceptions to our upper levels,
     # rather than printing help and exiting, so that we can meaningfully
     # respond with context-sensitive help if we want to. --daniel 2011-04-12
     option_parser.parse!(self.command_line.args)
   end
 
   def handlearg(opt, arg)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !arg
       opt = opt.gsub(/\[no-\]/,'no-')
     end
     # otherwise remove the [no-] prefix to not confuse everybody
     opt = opt.gsub(/\[no-\]/, '')
     unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
       # Puppet.settings.handlearg doesn't handle direct true/false :-)
       if arg.is_a?(FalseClass)
         arg = "false"
       elsif arg.is_a?(TrueClass)
         arg = "true"
       end
       Puppet.settings.handlearg(opt, arg)
     end
   end
 
   # this is used for testing
   def self.exit(code)
     exit(code)
   end
 
   def name
     self.class.to_s.sub(/.*::/,"").downcase.to_sym
   end
 
   def help
     "No help available for puppet #{name}"
   end
 
   private
 
   def exit_on_fail(message, code = 1)
     yield
   rescue ArgumentError, RuntimeError, NotImplementedError => detail
-    puts detail.backtrace if Puppet[:trace]
-    $stderr.puts "Could not #{message}: #{detail}"
+    Puppet.log_exception(detail, "Could not #{message}: #{detail}")
     exit(code)
   end
 
   def hook(step,&block)
     Puppet::Plugins.send("before_application_#{step}",:application_object => self)
     x = yield
     Puppet::Plugins.send("after_application_#{step}",:application_object => self, :return_value => x)
     x
   end
 end
 end
diff --git a/lib/puppet/application/agent.rb b/lib/puppet/application/agent.rb
index 191b3bf61..e0c5fdec5 100644
--- a/lib/puppet/application/agent.rb
+++ b/lib/puppet/application/agent.rb
@@ -1,485 +1,483 @@
 require 'puppet/application'
 
 class Puppet::Application::Agent < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   attr_accessor :args, :agent, :daemon, :host
 
   def preinit
     # Do an initial trap, so that cancels don't get a stack trace.
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     {
       :waitforcert => nil,
       :detailed_exitcodes => false,
       :verbose => false,
       :debug => false,
       :centrallogs => false,
       :setdest => false,
       :enable => false,
       :disable => false,
       :client => true,
       :fqdn => nil,
       :serve => [],
       :digest => :MD5,
       :graph => true,
       :fingerprint => false,
     }.each do |opt,val|
       options[opt] = val
     end
 
     @args = {}
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
   end
 
   option("--centrallogging")
 
   option("--disable [MESSAGE]") do |message|
     options[:disable] = true
     options[:disable_message] = message
   end
 
   option("--enable")
   option("--debug","-d")
   option("--fqdn FQDN","-f")
   option("--test","-t")
   option("--verbose","-v")
 
   option("--fingerprint")
   option("--digest DIGEST")
 
   option("--no-client") do |arg|
     options[:client] = false
   end
 
   option("--detailed-exitcodes") do |arg|
     options[:detailed_exitcodes] = true
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
-      $stderr.puts detail.to_s
+      Puppet.log_exception(detail)
     end
   end
 
   option("--waitforcert WAITFORCERT", "-w") do |arg|
     options[:waitforcert] = arg.to_i
   end
 
   option("--port PORT","-p") do |arg|
     @args[:Port] = arg
   end
 
   def help
     <<-HELP
 
 puppet-agent(8) -- The puppet agent daemon
 ========
 
 SYNOPSIS
 --------
 Retrieves the client configuration from the puppet master and applies it to
 the local host.
 
 This service may be run as a daemon, run periodically using cron (or something
 similar), or run interactively for testing purposes.
 
 
 USAGE
 -----
 puppet agent [--certname <name>] [-D|--daemonize|--no-daemonize]
   [-d|--debug] [--detailed-exitcodes] [--digest <digest>] [--disable [message]] [--enable]
   [--fingerprint] [-h|--help] [-l|--logdest syslog|<file>|console]
   [--no-client] [--noop] [-o|--onetime] [-t|--test]
   [-v|--verbose] [-V|--version] [-w|--waitforcert <seconds>]
 
 
 DESCRIPTION
 -----------
 This is the main puppet client. Its job is to retrieve the local
 machine's configuration from a remote server and apply it. In order to
 successfully communicate with the remote server, the client must have a
 certificate signed by a certificate authority that the server trusts;
 the recommended method for this, at the moment, is to run a certificate
 authority as part of the puppet server (which is the default). The
 client will connect and request a signed certificate, and will continue
 connecting until it receives one.
 
 Once the client has a signed certificate, it will retrieve its
 configuration and apply it.
 
 
 USAGE NOTES
 -----------
 'puppet agent' does its best to find a compromise between interactive
 use and daemon use. Run with no arguments and no configuration, it will
 go into the background, attempt to get a signed certificate, and retrieve
 and apply its configuration every 30 minutes.
 
 Some flags are meant specifically for interactive use -- in particular,
 'test', 'tags' or 'fingerprint' are useful. 'test' enables verbose
 logging, causes the daemon to stay in the foreground, exits if the
 server's configuration is invalid (this happens if, for instance, you've
 left a syntax error on the server), and exits after running the
 configuration once (rather than hanging around as a long-running
 process).
 
 'tags' allows you to specify what portions of a configuration you want
 to apply. Puppet elements are tagged with all of the class or definition
 names that contain them, and you can use the 'tags' flag to specify one
 of these names, causing only configuration elements contained within
 that class or definition to be applied. This is very useful when you are
 testing new configurations -- for instance, if you are just starting to
 manage 'ntpd', you would put all of the new elements into an 'ntpd'
 class, and call puppet with '--tags ntpd', which would only apply that
 small portion of the configuration during your testing, rather than
 applying the whole thing.
 
 'fingerprint' is a one-time flag. In this mode 'puppet agent' will run
 once and display on the console (and in the log) the current certificate
 (or certificate request) fingerprint. Providing the '--digest' option
 allows to use a different digest algorithm to generate the fingerprint.
 The main use is to verify that before signing a certificate request on
 the master, the certificate request the master received is the same as
 the one the client sent (to prevent against man-in-the-middle attacks
 when signing certificates).
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'server' is a valid
 configuration parameter, so you can specify '--server <servername>' as
 an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet agent with
 '--genconfig'.
 
 * --certname:
   Set the certname (unique ID) of the client. The master reads this
   unique identifying string, which is usually set to the node's
   fully-qualified domain name, to determine which configurations the
   node will receive. Use this option to debug setup problems or
   implement unusual node identification schemes.
 
 * --daemonize:
   Send the process into the background. This is the default.
 
 * --no-daemonize:
   Do not send the process into the background.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an exit
   code of '2' means there were changes, an exit code of '4' means there were
   failures during the transaction, and an exit code of '6' means there were both
   changes and failures.
 
 * --digest:
   Change the certificate fingerprinting digest algorithm. The default is
   MD5. Valid values depends on the version of OpenSSL installed, but
   should always at least contain MD5, MD2, SHA1 and SHA256.
 
 * --disable:
   Disable working on the local system. This puts a lock file in place,
   causing 'puppet agent' not to work on the system until the lock file
   is removed. This is useful if you are testing a configuration and do
   not want the central configuration to override the local state until
   everything is tested and committed.
 
   Disable can also take an optional message that will be reported by the
   'puppet agent' at the next disabled run.
 
   'puppet agent' uses the same lock file while it is running, so no more
   than one 'puppet agent' process is working at a time.
 
   'puppet agent' exits after executing this.
 
 * --enable:
   Enable working on the local system. This removes any lock file,
   causing 'puppet agent' to start managing the local system again
   (although it will continue to use its normal scheduling, so it might
   not start for another half hour).
 
   'puppet agent' exits after executing this.
 
 * --fingerprint:
   Display the current certificate or certificate signing request
   fingerprint and then exit. Use the '--digest' option to change the
   digest algorithm used.
 
 * --help:
   Print this help message
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to syslog, or the console if
   debugging or verbosity is enabled.
 
 * --no-client:
   Do not create a config client. This will cause the daemon to run
   without ever checking for its configuration automatically, and only
   makes sense when puppet agent is being run with listen = true in puppet.conf
   or was started with the `--listen` option.
 
 * --noop:
   Use 'noop' mode where the daemon runs in a no-op or dry-run mode. This
   is useful for seeing what changes Puppet will make without actually
   executing the changes.
 
 * --onetime:
   Run the configuration once. Runs a single (normally daemonized) Puppet
   run. Useful for interactively running puppet agent when used in
   conjunction with the --no-daemonize option.
 
 * --test:
   Enable the most common options used for testing. These are 'onetime',
   'verbose', 'ignorecache', 'no-daemonize', 'no-usecacheonfailure',
   'detailed-exit-codes', 'no-splay', and 'show_diff'.
 
 * --verbose:
   Turn on verbose reporting.
 
 * --version:
   Print the puppet version number and exit.
 
 * --waitforcert:
   This option only matters for daemons that do not yet have certificates
   and it is enabled by default, with a value of 120 (seconds). This
   causes 'puppet agent' to connect to the server every 2 minutes and ask
   it to sign a certificate request. This is useful for the initial setup
   of a puppet client. You can turn off waiting for certificates by
   specifying a time of 0.
 
 
 EXAMPLE
 -------
     $ puppet agent --server puppet.domain.com
 
 
 DIAGNOSTICS
 -----------
 
 Puppet agent accepts the following signals:
 
 * SIGHUP:
   Restart the puppet agent daemon.
 * SIGINT and SIGTERM:
   Shut down the puppet agent daemon.
 * SIGUSR1:
   Immediately retrieve and apply configurations from the puppet master.
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def run_command
     return fingerprint if options[:fingerprint]
     return onetime if Puppet[:onetime]
     main
   end
 
   def fingerprint
     unless cert = host.certificate || host.certificate_request
       $stderr.puts "Fingerprint asked but no certificate nor certificate request have yet been issued"
       exit(1)
       return
     end
     unless fingerprint = cert.fingerprint(options[:digest])
       raise ArgumentError, "Could not get fingerprint for digest '#{options[:digest]}'"
     end
     puts fingerprint
   end
 
   def onetime
     unless options[:client]
       $stderr.puts "onetime is specified but there is no client"
       exit(43)
       return
     end
 
     @daemon.set_signal_traps
 
     begin
       @agent.should_fork = false
       exitstatus = @agent.run
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err detail.to_s
+      Puppet.log_exception(detail)
     end
 
     @daemon.stop(:exit => false)
 
     if not exitstatus
       exit(1)
     elsif options[:detailed_exitcodes] then
       exit(exitstatus)
     else
       exit(0)
     end
   end
 
   def main
     Puppet.notice "Starting Puppet client version #{Puppet.version}"
 
     @daemon.start
   end
 
   # Enable all of the most common test options.
   def setup_test
     Puppet.settings.handlearg("--ignorecache")
     Puppet.settings.handlearg("--no-usecacheonfailure")
     Puppet.settings.handlearg("--no-splay")
     Puppet.settings.handlearg("--show_diff")
     Puppet.settings.handlearg("--no-daemonize")
     options[:verbose] = true
     Puppet[:onetime] = true
     options[:detailed_exitcodes] = true
   end
 
   # Handle the logging settings.
   def setup_logs
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def enable_disable_client(agent)
     if options[:enable]
       agent.enable
     elsif options[:disable]
       agent.disable(options[:disable_message] || 'reason not specified')
     end
     exit(0)
   end
 
   def setup_listen
     unless FileTest.exists?(Puppet[:rest_authconfig])
       Puppet.err "Will not start without authorization file #{Puppet[:rest_authconfig]}"
       exit(14)
     end
 
     require 'puppet/network/server'
     # No REST handlers yet.
     server = Puppet::Network::Server.new(:port => Puppet[:puppetport])
 
     @daemon.server = server
   end
 
   def setup_host
     @host = Puppet::SSL::Host.new
     waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
     cert = @host.wait_for_cert(waitforcert) unless options[:fingerprint]
   end
 
   def setup_agent
     # We need tomake the client either way, we just don't start it
     # if --no-client is set.
     require 'puppet/agent'
     require 'puppet/configurer'
     @agent = Puppet::Agent.new(Puppet::Configurer)
 
     enable_disable_client(@agent) if options[:enable] or options[:disable]
 
     @daemon.agent = agent if options[:client]
 
     # It'd be nice to daemonize later, but we have to daemonize before the
     # waitforcert happens.
     @daemon.daemonize if Puppet[:daemonize]
 
     setup_host
 
     @objects = []
 
     # This has to go after the certs are dealt with.
     if Puppet[:listen]
       unless Puppet[:onetime]
         setup_listen
       else
         Puppet.notice "Ignoring --listen on onetime run"
       end
     end
   end
 
   def setup
     setup_test if options[:test]
 
     setup_logs
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     args[:Server] = Puppet[:server]
     if options[:fqdn]
       args[:FQDN] = options[:fqdn]
       Puppet[:certname] = options[:fqdn]
     end
 
     if options[:centrallogs]
       logdest = args[:Server]
 
       logdest += ":" + args[:Port] if args.include?(:Port)
       Puppet::Util::Log.newdestination(logdest)
     end
 
     Puppet.settings.use :main, :agent, :ssl
 
     # Always ignoreimport for agent. It really shouldn't even try to import,
     # but this is just a temporary band-aid.
     Puppet[:ignoreimport] = true
 
     # We need to specify a ca location for all of the SSL-related i
     # indirected classes to work; in fingerprint mode we just need
     # access to the local files and we don't need a ca.
     Puppet::SSL::Host.ca_location = options[:fingerprint] ? :none : :remote
 
     Puppet::Transaction::Report.indirection.terminus_class = :rest
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
     # Override the default; puppetd needs this, usually.
     # You can still override this on the command-line with, e.g., :compiler.
     Puppet[:catalog_terminus] = :rest
 
     # Override the default.
     Puppet[:facts_terminus] = :facter
 
     Puppet::Resource::Catalog.indirection.cache_class = :yaml
 
     unless options[:fingerprint]
       setup_agent
     else
       setup_host
     end
   end
 end
diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index 95884d7d1..f66173447 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,275 +1,274 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
   should_parse_config
 
   option("--debug","-d")
   option("--execute EXECUTE","-e") do |arg|
     options[:code] = arg
   end
   option("--loadclasses","-L")
   option("--verbose","-v")
   option("--use-nodes")
   option("--detailed-exitcodes")
 
   option("--apply catalog",  "-a catalog") do |arg|
     Puppet.deprecation_warning <<EOM
 --apply is deprecated and will be removed in the future. Please
 use 'puppet apply --catalog <catalog>'.
 EOM
     options[:catalog] = arg
   end
 
   option("--catalog catalog",  "-c catalog") do |arg|
     options[:catalog] = arg
   end
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   option("--parseonly") do
     puts "--parseonly has been removed. Please use 'puppet parser validate <manifest>'"
     exit 1
   end
 
   def help
     <<-HELP
 
 puppet-apply(8) -- Apply Puppet manifests locally
 ========
 
 SYNOPSIS
 --------
 Applies a standalone Puppet manifest to the local system.
 
 
 USAGE
 -----
 puppet apply [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
   [-e|--execute] [--detailed-exitcodes] [-l|--logdest <file>]
   [--apply <catalog>] [--catalog <catalog>] <file>
 
 
 DESCRIPTION
 -----------
 This is the standalone puppet execution tool; use it to apply
 individual manifests.
 
 When provided with a modulepath, via command line or config file, puppet
 apply can effectively mimic the catalog that would be served by puppet
 master with access to the same modules, although there are some subtle
 differences. When combined with scheduling and an automated system for
 pushing manifests, this can be used to implement a serverless Puppet
 site.
 
 Most users should use 'puppet agent' and 'puppet master' for site-wide
 manifests.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'tags' is a
 valid configuration parameter, so you can specify '--tags <class>,<tag>'
 as an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an exit
   code of '2' means there were changes, an exit code of '4' means there were
   failures during the transaction, and an exit code of '6' means there were both
   changes and failures.
 
 * --help:
   Print this help message
 
 * --loadclasses:
   Load any stored classes. 'puppet agent' caches configured classes
   (usually at /etc/puppet/classes.txt), and setting this option causes
   all of those classes to be set in your puppet manifest.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to the console.
 
 * --execute:
   Execute a specific piece of Puppet code
 
 * --verbose:
   Print extra information.
 
 * --apply:
   Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
   either specify a JSON file or pipe in JSON from standard input. Deprecated, please
   use --catalog instead.
 
 * --catalog:
   Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
   either specify a JSON file or pipe in JSON from standard input.
 
 
 EXAMPLE
 -------
     $ puppet apply -l /tmp/manifest.log manifest.pp
     $ puppet apply --modulepath=/root/dev/modules -e "include ntpd::server"
     $ puppet apply --catalog catalog.json
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def run_command
     if options[:catalog]
       apply
     else
       main
     end
   end
 
   def apply
     if options[:catalog] == "-"
       text = $stdin.read
     else
       text = ::File.read(options[:catalog])
     end
     catalog = read_catalog(text)
     apply_catalog(catalog)
   end
 
   def main
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       manifest = command_line.args.shift
       raise "Could not find file #{manifest}" unless ::File.exist?(manifest)
       Puppet.warning("Only one file can be applied per run.  Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
       Puppet[:manifest] = manifest
     end
 
     # Collect our facts.
     unless facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
       raise "Could not find facts for #{Puppet[:node_name_value]}"
     end
 
     unless Puppet[:node_name_fact].empty?
       Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
       facts.name = Puppet[:node_name_value]
     end
 
     # Find our Node
     unless node = Puppet::Node.indirection.find(Puppet[:node_name_value])
       raise "Could not find node #{Puppet[:node_name_value]}"
     end
 
     # Merge in the facts.
     node.merge(facts.values)
 
     # Allow users to load the classes that puppet agent creates.
     if options[:loadclasses]
       file = Puppet[:classfile]
       if FileTest.exists?(file)
         unless FileTest.readable?(file)
           $stderr.puts "#{file} is not readable"
           exit(63)
         end
         node.classes = ::File.read(file).split(/[\s\n]+/)
       end
     end
 
     begin
       # Compile our catalog
       starttime = Time.now
       catalog = Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
 
       # Translate it to a RAL catalog
       catalog = catalog.to_ral
 
       catalog.finalize
 
       catalog.retrieval_duration = Time.now - starttime
 
       exit_status = apply_catalog(catalog)
 
       if not exit_status
         exit(1)
       elsif options[:detailed_exitcodes] then
         exit(exit_status)
       else
         exit(0)
       end
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      $stderr.puts detail.message
+      Puppet.log_exception(detail)
       exit(1)
     end
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
     client = nil
     server = nil
 
     Signal.trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
 
     # Make pluginsync local
     Puppet[:pluginsource] = 'puppet:///plugins'
   end
 
   private
 
   def read_catalog(text)
     begin
       catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
       catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
     rescue => detail
       raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
     end
 
     catalog.to_ral
   end
 
   def apply_catalog(catalog)
     require 'puppet/configurer'
     configurer = Puppet::Configurer.new
     configurer.run(:catalog => catalog)
   end
 end
diff --git a/lib/puppet/application/cert.rb b/lib/puppet/application/cert.rb
index 7b1431146..a21033440 100644
--- a/lib/puppet/application/cert.rb
+++ b/lib/puppet/application/cert.rb
@@ -1,241 +1,239 @@
 require 'puppet/application'
 
 class Puppet::Application::Cert < Puppet::Application
 
   should_parse_config
   run_mode :master
 
   attr_accessor :all, :ca, :digest, :signed
 
   def subcommand
     @subcommand
   end
 
   def subcommand=(name)
     # Handle the nasty, legacy mapping of "clean" to "destroy".
     sub = name.to_sym
     @subcommand = (sub == :clean ? :destroy : sub)
   end
 
   option("--clean", "-c") do |arg|
     self.subcommand = "destroy"
   end
 
   option("--all", "-a") do |arg|
     @all = true
   end
 
   option("--digest DIGEST") do |arg|
     @digest = arg
   end
 
   option("--signed", "-s") do |arg|
     @signed = true
   end
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   require 'puppet/ssl/certificate_authority/interface'
   Puppet::SSL::CertificateAuthority::Interface::INTERFACE_METHODS.reject {|m| m == :destroy }.each do |method|
     option("--#{method.to_s.gsub('_','-')}", "-#{method.to_s[0,1]}") do |arg|
       self.subcommand = method
     end
   end
 
   option("--[no-]allow-dns-alt-names") do |value|
     options[:allow_dns_alt_names] = value
   end
 
   option("--verbose", "-v") do |arg|
     Puppet::Util::Log.level = :info
   end
 
   def help
     <<-HELP
 
 puppet-cert(8) -- Manage certificates and requests
 ========
 
 SYNOPSIS
 --------
 Standalone certificate authority. Capable of generating certificates,
 but mostly used for signing certificate requests from puppet clients.
 
 
 USAGE
 -----
 puppet cert <action> [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
   [--digest <digest>] [<host>]
 
 
 DESCRIPTION
 -----------
 Because the puppet master service defaults to not signing client
 certificate requests, this script is available for signing outstanding
 requests. It can be used to list outstanding requests and then either
 sign them individually or sign all of them.
 
 ACTIONS
 -------
 
 Every action except 'list' and 'generate' requires a hostname to act on,
 unless the '--all' option is set.
 
 * clean:
   Revoke a host's certificate (if applicable) and remove all files
   related to that host from puppet cert's storage. This is useful when
   rebuilding hosts, since new certificate signing requests will only be
   honored if puppet cert does not have a copy of a signed certificate
   for that host. If '--all' is specified then all host certificates,
   both signed and unsigned, will be removed.
 
 * fingerprint:
   Print the DIGEST (defaults to md5) fingerprint of a host's
   certificate.
 
 * generate:
   Generate a certificate for a named client. A certificate/keypair will
   be generated for each client named on the command line.
 
 * list:
   List outstanding certificate requests. If '--all' is specified, signed
   certificates are also listed, prefixed by '+', and revoked or invalid
   certificates are prefixed by '-' (the verification outcome is printed
   in parenthesis).
 
 * print:
   Print the full-text version of a host's certificate.
 
 * revoke:
   Revoke the certificate of a client. The certificate can be specified
   either by its serial number (given as a decimal number or a
   hexadecimal number prefixed by '0x') or by its hostname. The
   certificate is revoked by adding it to the Certificate Revocation List
   given by the 'cacrl' configuration option. Note that the puppet master
   needs to be restarted after revoking certificates.
 
 * sign:
   Sign an outstanding certificate request.
 
 * verify:
   Verify the named certificate against the local CA certificate.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet cert with
 '--genconfig'.
 
 * --all:
   Operate on all items. Currently only makes sense with the 'sign',
   'clean', 'list', and 'fingerprint' actions.
 
 * --digest:
   Set the digest for fingerprinting (defaults to md5). Valid values
   depends on your openssl and openssl ruby extension version, but should
   contain at least md5, sha1, md2, sha256.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message
 
 * --verbose:
   Enable verbosity.
 
 * --version:
   Print the puppet version number and exit.
 
 
 EXAMPLE
 -------
     $ puppet cert list
     culain.madstop.com
     $ puppet cert sign culain.madstop.com
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def main
     if @all
       hosts = :all
     elsif @signed
       hosts = :signed
     else
       hosts = command_line.args.collect { |h| h.downcase }
     end
     begin
       @ca.apply(:revoke, options.merge(:to => hosts)) if subcommand == :destroy
       @ca.apply(subcommand, options.merge(:to => hosts, :digest => @digest))
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      puts detail.to_s
+      Puppet.log_exception(detail)
       exit(24)
     end
   end
 
   def setup
     require 'puppet/ssl/certificate_authority'
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet::Util::Log.newdestination :console
 
     if [:generate, :destroy].include? subcommand
       Puppet::SSL::Host.ca_location = :local
     else
       Puppet::SSL::Host.ca_location = :only
     end
 
     # If we are generating, and the option came from the CLI, it gets added to
     # the data.  This will do the right thing for non-local certificates, in
     # that the command line but *NOT* the config file option will apply.
     if subcommand == :generate
       if Puppet.settings.setting(:dns_alt_names).setbycli
         options[:dns_alt_names] = Puppet[:dns_alt_names]
       end
     end
 
     begin
       @ca = Puppet::SSL::CertificateAuthority.new
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      puts detail.to_s
+      Puppet.log_exception(detail)
       exit(23)
     end
   end
 
   def parse_options
     # handle the bareword subcommand pattern.
     result = super
     unless self.subcommand then
       if sub = self.command_line.args.shift then
         self.subcommand = sub
       else
         puts help
         exit
       end
     end
     result
   end
 end
diff --git a/lib/puppet/application/device.rb b/lib/puppet/application/device.rb
index 89d597de0..d338c130b 100644
--- a/lib/puppet/application/device.rb
+++ b/lib/puppet/application/device.rb
@@ -1,256 +1,254 @@
 require 'puppet/application'
 require 'puppet/util/network_device'
 
 
 class Puppet::Application::Device < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   attr_accessor :args, :agent, :host
 
   def preinit
     # Do an initial trap, so that cancels don't get a stack trace.
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     {
       :waitforcert => nil,
       :detailed_exitcodes => false,
       :verbose => false,
       :debug => false,
       :centrallogs => false,
       :setdest => false,
     }.each do |opt,val|
       options[opt] = val
     end
 
     @args = {}
   end
 
   option("--centrallogging")
   option("--debug","-d")
   option("--verbose","-v")
 
   option("--detailed-exitcodes") do |arg|
     options[:detailed_exitcodes] = true
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
-      $stderr.puts detail.to_s
+      Puppet.log_exception(detail)
     end
   end
 
   option("--waitforcert WAITFORCERT", "-w") do |arg|
     options[:waitforcert] = arg.to_i
   end
 
   option("--port PORT","-p") do |arg|
     @args[:Port] = arg
   end
 
     def help
       <<-HELP
 
 puppet-device(8) -- Manage remote network devices
 ========
 
 SYNOPSIS
 --------
 Retrieves all configurations from the puppet master and apply
 them to the remote devices configured in /etc/puppet/device.conf.
 
 Currently must be run out periodically, using cron or something similar.
 
 USAGE
 -----
   puppet device [-d|--debug] [--detailed-exitcodes] [-V|--version]
                 [-h|--help] [-l|--logdest syslog|<file>|console]
                 [-v|--verbose] [-w|--waitforcert <seconds>]
 
 
 DESCRIPTION
 -----------
 Once the client has a signed certificate for a given remote device, it will
 retrieve its configuration and apply it.
 
 USAGE NOTES
 -----------
 One need a /etc/puppet/device.conf file with the following content:
 
 [remote.device.fqdn]
 type <type>
 url <url>
 
 where:
  * type: the current device type (the only value at this time is cisco)
  * url: an url allowing to connect to the device
 
 Supported url must conforms to:
  scheme://user:password@hostname/?query
 
  with:
   * scheme: either ssh or telnet
   * user: username, can be omitted depending on the switch/router configuration
   * password: the connection password
   * query: this is device specific. Cisco devices supports an enable parameter whose
   value would be the enable password.
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration file
 is also a valid long argument.  For example, 'server' is a valid configuration
 parameter, so you can specify '--server <servername>' as an argument.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an exit
   code of '2' means there were changes, an exit code of '4' means there were
   failures during the transaction, and an exit code of '6' means there were both
   changes and failures.
 
 * --help:
   Print this help message
 
 * --logdest:
   Where to send messages.  Choose between syslog, the console, and a log file.
   Defaults to sending messages to syslog, or the console if debugging or
   verbosity is enabled.
 
 * --verbose:
   Turn on verbose reporting.
 
 * --waitforcert:
   This option only matters for daemons that do not yet have certificates
   and it is enabled by default, with a value of 120 (seconds).  This causes
   +puppet agent+ to connect to the server every 2 minutes and ask it to sign a
   certificate request.  This is useful for the initial setup of a puppet
   client.  You can turn off waiting for certificates by specifying a time
   of 0.
 
 EXAMPLE
 -------
       $ puppet device --server puppet.domain.com
 
 AUTHOR
 ------
 Brice Figureau
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC
 Licensed under the Apache 2.0 License
       HELP
     end
 
 
   def main
     vardir = Puppet[:vardir]
     confdir = Puppet[:confdir]
     certname = Puppet[:certname]
 
     # find device list
     require 'puppet/util/network_device/config'
     devices = Puppet::Util::NetworkDevice::Config.devices
     if devices.empty?
       Puppet.err "No device found in #{Puppet[:deviceconfig]}"
       exit(1)
     end
     devices.each_value do |device|
       begin
         Puppet.info "starting applying configuration to #{device.name} at #{device.url}"
 
         # override local $vardir and $certname
         Puppet.settings.set_value(:confdir, ::File.join(Puppet[:devicedir], device.name), :cli)
         Puppet.settings.set_value(:vardir, ::File.join(Puppet[:devicedir], device.name), :cli)
         Puppet.settings.set_value(:certname, device.name, :cli)
 
         # this will reload and recompute default settings and create the devices sub vardir, or we hope so :-)
         Puppet.settings.use :main, :agent, :ssl
 
         # this init the device singleton, so that the facts terminus
         # and the various network_device provider can use it
         Puppet::Util::NetworkDevice.init(device)
 
         # ask for a ssl cert if needed, but at least
         # setup the ssl system for this device.
         setup_host
 
         require 'puppet/configurer'
         configurer = Puppet::Configurer.new
         report = configurer.run(:network_device => true)
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err detail.to_s
+        Puppet.log_exception(detail)
       ensure
         Puppet.settings.set_value(:vardir, vardir, :cli)
         Puppet.settings.set_value(:confdir, confdir, :cli)
         Puppet.settings.set_value(:certname, certname, :cli)
         Puppet::SSL::Host.reset
       end
     end
   end
 
   # Handle the logging settings.
   def setup_logs
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def setup_host
     @host = Puppet::SSL::Host.new
     waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : Puppet[:waitforcert])
     cert = @host.wait_for_cert(waitforcert)
   end
 
   def setup
     setup_logs
 
     args[:Server] = Puppet[:server]
     if options[:centrallogs]
       logdest = args[:Server]
 
       logdest += ":" + args[:Port] if args.include?(:Port)
       Puppet::Util::Log.newdestination(logdest)
     end
 
     Puppet.settings.use :main, :agent, :device, :ssl
 
     # Always ignoreimport for agent. It really shouldn't even try to import,
     # but this is just a temporary band-aid.
     Puppet[:ignoreimport] = true
 
     # We need to specify a ca location for all of the SSL-related i
     # indirected classes to work; in fingerprint mode we just need
     # access to the local files and we don't need a ca.
     Puppet::SSL::Host.ca_location = :remote
 
     Puppet::Transaction::Report.indirection.terminus_class = :rest
 
     # Override the default; puppetd needs this, usually.
     # You can still override this on the command-line with, e.g., :compiler.
     Puppet[:catalog_terminus] = :rest
 
     Puppet[:facts_terminus] = :network_device
 
     Puppet::Resource::Catalog.indirection.cache_class = :yaml
   end
 end
diff --git a/lib/puppet/application/doc.rb b/lib/puppet/application/doc.rb
index d2683b0d2..39e744e06 100644
--- a/lib/puppet/application/doc.rb
+++ b/lib/puppet/application/doc.rb
@@ -1,275 +1,273 @@
 require 'puppet/application'
 
 class Puppet::Application::Doc < Puppet::Application
   should_not_parse_config
   run_mode :master
 
   attr_accessor :unknown_args, :manifest
 
   def preinit
     {:references => [], :mode => :text, :format => :to_markdown }.each do |name,value|
       options[name] = value
     end
     @unknown_args = []
     @manifest = false
   end
 
   option("--all","-a")
   option("--outputdir OUTPUTDIR","-o")
   option("--verbose","-v")
   option("--debug","-d")
   option("--charset CHARSET")
 
   option("--format FORMAT", "-f") do |arg|
     method = "to_#{arg}"
     require 'puppet/util/reference'
     if Puppet::Util::Reference.method_defined?(method)
       options[:format] = method
     else
       raise "Invalid output format #{arg}"
     end
   end
 
   option("--mode MODE", "-m") do |arg|
     require 'puppet/util/reference'
     if Puppet::Util::Reference.modes.include?(arg) or arg.intern==:rdoc
       options[:mode] = arg.intern
     else
       raise "Invalid output mode #{arg}"
     end
   end
 
   option("--list", "-l") do |arg|
     require 'puppet/util/reference'
     puts Puppet::Util::Reference.references.collect { |r| Puppet::Util::Reference.reference(r).doc }.join("\n")
     exit(0)
   end
 
   option("--reference REFERENCE", "-r") do |arg|
     options[:references] << arg.intern
   end
 
   def help
     <<-HELP
 
 puppet-doc(8) -- Generate Puppet documentation and references
 ========
 
 SYNOPSIS
 --------
 Generates a reference for all Puppet types. Largely meant for internal
 Puppet Labs use.
 
 
 USAGE
 -----
 puppet doc [-a|--all] [-h|--help] [-o|--outputdir <rdoc-outputdir>]
   [-m|--mode text|pdf|rdoc] [-r|--reference <reference-name>]
   [--charset <charset>] [<manifest-file>]
 
 
 DESCRIPTION
 -----------
 If mode is not 'rdoc', then this command generates a Markdown document
 describing all installed Puppet types or all allowable arguments to
 puppet executables. It is largely meant for internal use and is used to
 generate the reference document available on the Puppet Labs web site.
 
 In 'rdoc' mode, this command generates an html RDoc hierarchy describing
 the manifests that are in 'manifestdir' and 'modulepath' configuration
 directives. The generated documentation directory is doc by default but
 can be changed with the 'outputdir' option.
 
 If the command is run with the name of a manifest file as an argument,
 puppet doc will output a single manifest's documentation on stdout.
 
 
 OPTIONS
 -------
 * --all:
   Output the docs for all of the reference types. In 'rdoc' mode, this also
   outputs documentation for all resources.
 
 * --help:
   Print this help message
 
 * --outputdir:
   Used only in 'rdoc' mode. The directory to which the rdoc output should
   be written.
 
 * --mode:
   Determine the output mode. Valid modes are 'text', 'pdf' and 'rdoc'. The 'pdf'
   mode creates PDF formatted files in the /tmp directory. The default mode is
   'text'. In 'rdoc' mode you must provide 'manifests-path'
 
 * --reference:
   Build a particular reference. Get a list of references by running
   'puppet doc --list'.
 
 * --charset:
   Used only in 'rdoc' mode. It sets the charset used in the html files produced.
 
 * --manifestdir:
   Used only in 'rdoc' mode. The directory to scan for stand-alone manifests.
   If not supplied, puppet doc will use the manifestdir from puppet.conf.
 
 * --modulepath:
   Used only in 'rdoc' mode. The directory or directories to scan for modules.
   If not supplied, puppet doc will use the modulepath from puppet.conf.
 
 * --environment:
   Used only in 'rdoc' mode. The configuration environment from which
   to read the modulepath and manifestdir settings, when reading said settings
   from puppet.conf. Due to a known bug, this option is not currently effective.
 
 
 EXAMPLE
 -------
     $ puppet doc -r type > /tmp/type_reference.markdown
 
 or
 
     $ puppet doc --outputdir /tmp/rdoc --mode rdoc /path/to/manifests
 
 or
 
     $ puppet doc /etc/puppet/manifests/site.pp
 
 or
 
     $ puppet doc -m pdf -r configuration
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
 HELP
   end
 
   def handle_unknown( opt, arg )
     @unknown_args << {:opt => opt, :arg => arg }
     true
   end
 
   def run_command
     return[:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
   end
 
   def rdoc
     exit_code = 0
     files = []
     unless @manifest
       env = Puppet::Node::Environment.new
       files += env.modulepath
       files << ::File.dirname(env[:manifest])
     end
     files += command_line.args
     Puppet.info "scanning: #{files.inspect}"
 
     Puppet.settings[:document_all] = options[:all] || false
     begin
       require 'puppet/util/rdoc'
       if @manifest
         Puppet::Util::RDoc.manifestdoc(files)
       else
         options[:outputdir] = "doc" unless options[:outputdir]
         Puppet::Util::RDoc.rdoc(options[:outputdir], files, options[:charset])
       end
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      $stderr.puts "Could not generate documentation: #{detail}"
+      Puppet.log_exception(detail, "Could not generate documentation: #{detail}")
       exit_code = 1
     end
     exit exit_code
   end
 
   def other
     text = ""
     with_contents = options[:references].length <= 1
     exit_code = 0
     require 'puppet/util/reference'
     options[:references].sort { |a,b| a.to_s <=> b.to_s }.each do |name|
       raise "Could not find reference #{name}" unless section = Puppet::Util::Reference.reference(name)
 
       begin
         # Add the per-section text, but with no ToC
         text += section.send(options[:format], with_contents)
       rescue => detail
-        puts detail.backtrace
-        $stderr.puts "Could not generate reference #{name}: #{detail}"
+        Puppet.log_exception(detail, "Could not generate reference #{name}: #{detail}")
         exit_code = 1
         next
       end
     end
 
     text += Puppet::Util::Reference.footer unless with_contents # We've only got one reference
 
     if options[:mode] == :pdf
       Puppet::Util::Reference.pdf(text)
     else
       puts text
     end
 
     exit exit_code
   end
 
   def setup
     # sole manifest documentation
     if command_line.args.size > 0
       options[:mode] = :rdoc
       @manifest = true
     end
 
     if options[:mode] == :rdoc
       setup_rdoc
     else
       setup_reference
     end
   end
 
   def setup_reference
     if options[:all]
       # Don't add dynamic references to the "all" list.
       require 'puppet/util/reference'
       options[:references] = Puppet::Util::Reference.references.reject do |ref|
         Puppet::Util::Reference.reference(ref).dynamic?
       end
     end
 
     options[:references] << :type if options[:references].empty?
   end
 
   def setup_rdoc(dummy_argument=:work_arround_for_ruby_GC_bug)
     # consume the unknown options
     # and feed them as settings
     if @unknown_args.size > 0
       @unknown_args.each do |option|
         # force absolute path for modulepath when passed on commandline
         if option[:opt]=="--modulepath" or option[:opt] == "--manifestdir"
           option[:arg] = option[:arg].split(::File::PATH_SEPARATOR).collect { |p| ::File.expand_path(p) }.join(::File::PATH_SEPARATOR)
         end
         Puppet.settings.handlearg(option[:opt], option[:arg])
       end
     end
 
     # Now parse the config
     Puppet.parse_config
 
     # Handle the logging settings.
     if options[:debug] or options[:verbose]
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
 
       Puppet::Util::Log.newdestination(:console)
     end
   end
 end
diff --git a/lib/puppet/application/face_base.rb b/lib/puppet/application/face_base.rb
index 14ce67b42..cb31ed802 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,254 +1,253 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   should_parse_config
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do
     Puppet::Util::Log.level = :info
   end
 
   option("--render-as FORMAT") do |format|
     self.render_as = format.to_sym
   end
 
   option("--mode RUNMODE", "-r") do |arg|
     raise "Invalid run mode #{arg}; supported modes are user, agent, master" unless %w{user agent master}.include?(arg)
     self.class.run_mode(arg.to_sym)
     set_run_mode self.class.run_mode
   end
 
 
   attr_accessor :face, :action, :type, :arguments, :render_as
 
   def render_as=(format)
     if format == :json then
       @render_as = Puppet::Network::FormatHandler.format(:pson)
     else
       @render_as = Puppet::Network::FormatHandler.format(format)
     end
     @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
   end
 
   def render(result, args_and_options)
     hook = action.when_rendering(render_as.name)
 
     if hook
       # when defining when_rendering on your action you can optionally
       # include arguments and options
       if hook.arity > 1
         result = hook.call(result, *args_and_options)
       else
         result = hook.call(result)
       end
     end
 
     render_as.render(result)
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
     @type = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
     @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
     action_name = nil
     index       = -1
     until action_name or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             index += 1          # ...so skip the argument.
           end
         elsif option = find_application_argument(item) then
           index += 1 if (option[:argument] and not option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
         # Stash away the requested action name for later, and try to fetch the
         # action object it represents; if this is an invalid action name that
         # will be nil, and handled later.
         action_name = item.to_sym
         @action = Puppet::Face.find_action(@face.name, action_name)
         @face   = @action.face if @action
       end
     end
 
     if @action.nil?
       if @action = @face.get_default_action() then
         @is_default_action = true
       else
         # REVISIT: ...and this horror thanks to our log setup, which doesn't
         # initialize destinations until the setup method, which we will never
         # reach.  We could also just print here, but that is actually a little
         # uglier and nastier in the long term, in which we should do log setup
         # earlier if at all possible. --daniel 2011-05-31
         Puppet::Util::Log.newdestination(:console)
 
         face   = @face.name
         action = action_name.nil? ? 'default' : "'#{action_name}'"
         msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
         Puppet.err(msg)
 
         exit false
       end
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
     @action.options.each do |option|
       option = @action.get_option(option) # make it the object.
       self.class.option(*option.optparse) # ...and make the CLI parse it.
     end
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
   def find_application_argument(item)
     self.class.option_parser_commands.each do |options, function|
       options.each do |option|
         next unless option =~ /^-/
         pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         next unless pattern.match(item)
         return {
           :argument => option =~ /[ =]/,
           :optional => option =~ /[ =]\[/
         }
       end
     end
     return nil                  # not found
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
 
     # If we don't have a rendering format, set one early.
     self.render_as ||= (@action.render_as || :console)
   end
 
 
   def main
     status = false
 
     # Call the method associated with the provided action (e.g., 'find').
     unless @action
       puts Puppet::Face[:help, :current].help(@face.name)
       raise "#{face} does not respond to action #{arguments.first}"
     end
 
     # We need to do arity checking here because this is generic code
     # calling generic methods – that have argument defaulting.  We need to
     # make sure we don't accidentally pass the options as the first
     # argument to a method that takes one argument.  eg:
     #
     #   puppet facts find
     #   => options => {}
     #      @arguments => [{}]
     #   => @face.send :bar, {}
     #
     #   def face.bar(argument, options = {})
     #   => bar({}, {})  # oops!  we thought the options were the
     #                   # positional argument!!
     #
     # We could also fix this by making it mandatory to pass the options on
     # every call, but that would make the Ruby API much more annoying to
     # work with; having the defaulting is a much nicer convention to have.
     #
     # We could also pass the arguments implicitly, by having a magic
     # 'options' method that was visible in the scope of the action, which
     # returned the right stuff.
     #
     # That sounds attractive, but adds complications to all sorts of
     # things, especially when you think about how to pass options when you
     # are writing Ruby code that calls multiple faces.  Especially if
     # faces are involved in that. ;)
     #
     # --daniel 2011-04-27
     if (arity = @action.positional_arg_count) > 0
       unless (count = arguments.length) == arity then
         s = arity == 2 ? '' : 's'
         raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
       end
     end
 
     result = @face.send(@action.name, *arguments)
     puts render(result, arguments) unless result.nil?
     status = true
 
   rescue Exception => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err detail.to_s
+    Puppet.log_exception(detail)
     Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
 
   ensure
     exit status
   end
 end
diff --git a/lib/puppet/application/filebucket.rb b/lib/puppet/application/filebucket.rb
index f78e9370a..472e62c85 100644
--- a/lib/puppet/application/filebucket.rb
+++ b/lib/puppet/application/filebucket.rb
@@ -1,191 +1,190 @@
 require 'puppet/application'
 
 class Puppet::Application::Filebucket < Puppet::Application
 
   should_not_parse_config
 
   option("--bucket BUCKET","-b")
   option("--debug","-d")
   option("--local","-l")
   option("--remote","-r")
   option("--verbose","-v")
 
   attr :args
 
   def help
     <<-HELP
 
 puppet-filebucket(8) -- Store and retrieve files in a filebucket
 ========
 
 SYNOPSIS
 --------
 A stand-alone Puppet filebucket client.
 
 
 USAGE
 -----
 puppet filebucket <mode> [-h|--help] [-V|--version] [-d|--debug]
   [-v|--verbose] [-l|--local] [-r|--remote] [-s|--server <server>]
   [-b|--bucket <directory>] <file> <file> ...
 
 Puppet filebucket can operate in three modes, with only one mode per call:
 
 backup:
   Send one or more files to the specified file bucket. Each sent file is
   printed with its resulting md5 sum.
 
 get:
   Return the text associated with an md5 sum. The text is printed to
   stdout, and only one file can be retrieved at a time.
 
 restore:
   Given a file path and an md5 sum, store the content associated with
   the sum into the specified file path. You can specify an entirely new
   path to this argument; you are not restricted to restoring the content
   to its original location.
 
 
 DESCRIPTION
 -----------
 This is a stand-alone filebucket client for sending files to a local or
 central filebucket.
 
 Note that 'filebucket' defaults to using a network-based filebucket
 available on the server named 'puppet'. To use this, you'll have to be
 running as a user with valid Puppet certificates. Alternatively, you can
 use your local file bucket by specifying '--local'.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message
 
 * --local:
   Use the local filebucket. This will use the default configuration
   information.
 
 * --remote:
   Use a remote filebucket. This will use the default configuration
   information.
 
 * --server:
   The server to send the file to, instead of locally.
 
 * --verbose:
   Print extra information.
 
 * --version:
   Print version information.
 
 
 EXAMPLE
 -------
     $ puppet filebucket backup /etc/passwd
     /etc/passwd: 429b225650b912a2ee067b0a4cf1e949
     $ puppet filebucket restore /tmp/passwd 429b225650b912a2ee067b0a4cf1e949
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
 
   def run_command
     @args = command_line.args
     command = args.shift
     return send(command) if %w{get backup restore}.include? command
     help
   end
 
   def get
     md5 = args.shift
     out = @client.getfile(md5)
     print out
   end
 
   def backup
     raise "You must specify a file to back up" unless args.length > 0
 
     args.each do |file|
       unless FileTest.exists?(file)
         $stderr.puts "#{file}: no such file"
         next
       end
       unless FileTest.readable?(file)
         $stderr.puts "#{file}: cannot read file"
         next
       end
       md5 = @client.backup(file)
       puts "#{file}: #{md5}"
     end
   end
 
   def restore
     file = args.shift
     md5 = args.shift
     @client.restore(file, md5)
   end
 
   def setup
     Puppet::Log.newdestination(:console)
 
     @client = nil
     @server = nil
 
     Signal.trap(:INT) do
       $stderr.puts "Cancelling"
       exit(1)
     end
 
     if options[:debug]
       Puppet::Log.level = :debug
     elsif options[:verbose]
       Puppet::Log.level = :info
     end
 
     # Now parse the config
     Puppet.parse_config
 
       exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     require 'puppet/file_bucket/dipper'
     begin
       if options[:local] or options[:bucket]
         path = options[:bucket] || Puppet[:bucketdir]
         @client = Puppet::FileBucket::Dipper.new(:Path => path)
       else
         @client = Puppet::FileBucket::Dipper.new(:Server => Puppet[:server])
       end
     rescue => detail
-      $stderr.puts detail
-      puts detail.backtrace if Puppet[:trace]
+      Puppet.log_exception(detail)
       exit(1)
     end
   end
 
 end
 
diff --git a/lib/puppet/application/inspect.rb b/lib/puppet/application/inspect.rb
index 5413a3d8c..a0f61e296 100644
--- a/lib/puppet/application/inspect.rb
+++ b/lib/puppet/application/inspect.rb
@@ -1,191 +1,189 @@
 require 'puppet/application'
 
 class Puppet::Application::Inspect < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   option("--debug","-d")
   option("--verbose","-v")
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   def help
     <<-HELP
 
 puppet-inspect(8) -- Send an inspection report
 ========
 
 SYNOPSIS
 --------
 
 Prepares and submits an inspection report to the puppet master.
 
 
 USAGE
 -----
 puppet inspect [--archive_files] [--archive_file_server]
 
 
 DESCRIPTION
 -----------
 
 This command uses the cached catalog from the previous run of 'puppet
 agent' to determine which attributes of which resources have been
 marked as auditable with the 'audit' metaparameter. It then examines
 the current state of the system, writes the state of the specified
 resource attributes to a report, and submits the report to the puppet
 master.
 
 Puppet inspect does not run as a daemon, and must be run manually or
 from cron.
 
 
 OPTIONS
 -------
 
 Any configuration setting which is valid in the configuration file is
 also a valid long argument, e.g. '--server=master.domain.com'. See the
 configuration file documentation at
 http://docs.puppetlabs.com/references/latest/configuration.html for
 the full list of acceptable settings.
 
 * --archive_files:
   During an inspect run, whether to archive files whose contents are audited to
   a file bucket.
 
 * --archive_file_server:
   During an inspect run, the file bucket server to archive files to if
   archive_files is set.  The default value is '$server'.
 
 
 AUTHOR
 ------
 
 Puppet Labs
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     raise "Inspect requires reporting to be enabled. Set report=true in puppet.conf to enable reporting." unless Puppet[:report]
 
     @report = Puppet::Transaction::Report.new("inspect")
 
     Puppet::Util::Log.newdestination(@report)
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
 
     Signal.trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
 
     Puppet::Transaction::Report.indirection.terminus_class = :rest
     Puppet::Resource::Catalog.indirection.terminus_class = :yaml
   end
 
   def preinit
     require 'puppet'
     require 'puppet/file_bucket/dipper'
   end
 
   def run_command
     benchmark(:notice, "Finished inspection") do
       retrieval_starttime = Time.now
 
       unless catalog = Puppet::Resource::Catalog.indirection.find(Puppet[:certname])
         raise "Could not find catalog for #{Puppet[:certname]}"
       end
 
       @report.configuration_version = catalog.version
       @report.environment = Puppet[:environment]
 
       inspect_starttime = Time.now
       @report.add_times("config_retrieval", inspect_starttime - retrieval_starttime)
 
       if Puppet[:archive_files]
         dipper = Puppet::FileBucket::Dipper.new(:Server => Puppet[:archive_file_server])
       end
 
       catalog.to_ral.resources.each do |ral_resource|
         audited_attributes = ral_resource[:audit]
         next unless audited_attributes
 
         status = Puppet::Resource::Status.new(ral_resource)
 
         begin
           audited_resource = ral_resource.to_resource
         rescue StandardError => detail
-          puts detail.backtrace if Puppet[:trace]
-          ral_resource.err "Could not inspect #{ral_resource}; skipping: #{detail}"
+          ral_resource.log_exception(detail, "Could not inspect #{ral_resource}; skipping: #{detail}")
           audited_attributes.each do |name|
             event = ral_resource.event(
                                        :property => name,
                                        :status   => "failure",
                                        :audited  => true,
                                        :message  => "failed to inspect #{name}"
                                        )
             status.add_event(event)
           end
         else
           audited_attributes.each do |name|
             next if audited_resource[name].nil?
             # Skip :absent properties of :absent resources. Really, it would be nicer if the RAL returned nil for those, but it doesn't. ~JW
             if name == :ensure or audited_resource[:ensure] != :absent or audited_resource[name] != :absent
               event = ral_resource.event(
                                          :previous_value => audited_resource[name],
                                          :property       => name,
                                          :status         => "audit",
                                          :audited        => true,
                                          :message        => "inspected value is #{audited_resource[name].inspect}"
                                          )
               status.add_event(event)
             end
           end
         end
         if Puppet[:archive_files] and ral_resource.type == :file and audited_attributes.include?(:content)
           path = ral_resource[:path]
           if ::File.readable?(path)
             begin
               dipper.backup(path)
             rescue StandardError => detail
               Puppet.warning detail
             end
           end
         end
         @report.add_resource_status(status)
       end
 
       finishtime = Time.now
       @report.add_times("inspect", finishtime - inspect_starttime)
       @report.finalize_report
 
       begin
         Puppet::Transaction::Report.indirection.save(@report)
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not send report: #{detail}"
+        Puppet.log_exception(detail, "Could not send report: #{detail}")
       end
     end
   end
 end
diff --git a/lib/puppet/application/kick.rb b/lib/puppet/application/kick.rb
index bf6178e7a..9abd86c0a 100644
--- a/lib/puppet/application/kick.rb
+++ b/lib/puppet/application/kick.rb
@@ -1,337 +1,336 @@
 require 'puppet/application'
 
 class Puppet::Application::Kick < Puppet::Application
 
   should_not_parse_config
 
   attr_accessor :hosts, :tags, :classes
 
   option("--all","-a")
   option("--foreground","-f")
   option("--debug","-d")
   option("--ping","-P")
   option("--test")
 
   option("--host HOST") do |arg|
     @hosts << arg
   end
 
   option("--tag TAG", "-t") do |arg|
     @tags << arg
   end
 
   option("--class CLASS", "-c") do |arg|
     @classes << arg
   end
 
   option("--no-fqdn", "-n") do |arg|
     options[:fqdn] = false
   end
 
   option("--parallel PARALLEL", "-p") do |arg|
     begin
       options[:parallel] = Integer(arg)
     rescue
       $stderr.puts "Could not convert #{arg.inspect} to an integer"
       exit(23)
     end
   end
 
   def help
     <<-HELP
 
 puppet-kick(8) -- Remotely control puppet agent
 ========
 
 SYNOPSIS
 --------
 Trigger a puppet agent run on a set of hosts.
 
 
 USAGE
 -----
 puppet kick [-a|--all] [-c|--class <class>] [-d|--debug] [-f|--foreground]
   [-h|--help] [--host <host>] [--no-fqdn] [--ignoreschedules]
   [-t|--tag <tag>] [--test] [-p|--ping] <host> [<host> [...]]
 
 
 DESCRIPTION
 -----------
 This script can be used to connect to a set of machines running 'puppet
 agent' and trigger them to run their configurations. The most common
 usage would be to specify a class of hosts and a set of tags, and
 'puppet kick' would look up in LDAP all of the hosts matching that
 class, then connect to each host and trigger a run of all of the objects
 with the specified tags.
 
 If you are not storing your host configurations in LDAP, you can specify
 hosts manually.
 
 You will most likely have to run 'puppet kick' as root to get access to
 the SSL certificates.
 
 'puppet kick' reads 'puppet master''s configuration file, so that it can
 copy things like LDAP settings.
 
 
 USAGE NOTES
 -----------
 Puppet kick is useless unless puppet agent is listening for incoming
 connections and allowing access to the `run` endpoint. This entails
 starting the agent with `listen = true` in its puppet.conf file, and
 allowing access to the `/run` path in its auth.conf file; see
 `http://docs.puppetlabs.com/guides/rest_auth_conf.html` for more
 details.
 
 Additionally, due to a known bug, you must make sure a
 namespaceauth.conf file exists in puppet agent's $confdir. This file
 will not be consulted, and may be left empty.  
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/latest/configuration.html for
 the full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet master
 with '--genconfig'.
 
 * --all:
   Connect to all available hosts. Requires LDAP support at this point.
 
 * --class:
   Specify a class of machines to which to connect. This only works if
   you have LDAP configured, at the moment.
 
 * --debug:
   Enable full debugging.
 
 * --foreground:
   Run each configuration in the foreground; that is, when connecting to
   a host, do not return until the host has finished its run. The default
   is false.
 
 * --help:
   Print this help message
 
 * --host:
   A specific host to which to connect. This flag can be specified more
   than once.
 
 * --ignoreschedules:
   Whether the client should ignore schedules when running its
   configuration. This can be used to force the client to perform work it
   would not normally perform so soon. The default is false.
 
 * --parallel:
   How parallel to make the connections. Parallelization is provided by
   forking for each client to which to connect. The default is 1, meaning
   serial execution.
 
 * --tag:
   Specify a tag for selecting the objects to apply. Does not work with
   the --test option.
 
 * --test:
   Print the hosts you would connect to but do not actually connect. This
   option requires LDAP support at this point.
 
 * --ping:
   Do a ICMP echo against the target host. Skip hosts that don't respond
   to ping.
 
 
 EXAMPLE
 -------
     $ sudo puppet kick -p 10 -t remotefile -t webserver host1 host2
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def run_command
     @hosts += command_line.args
     options[:test] ? test : main
   end
 
   def test
     puts "Skipping execution in test mode"
     exit(0)
   end
 
   def main
     Puppet.warning "Failed to load ruby LDAP library. LDAP functionality will not be available" unless Puppet.features.ldap?
     require 'puppet/util/ldap/connection'
 
     todo = @hosts.dup
 
     failures = []
 
     # Now do the actual work
     go = true
     while go
       # If we don't have enough children in process and we still have hosts left to
       # do, then do the next host.
       if @children.length < options[:parallel] and ! todo.empty?
         host = todo.shift
         pid = fork do
           run_for_host(host)
         end
         @children[pid] = host
       else
         # Else, see if we can reap a process.
         begin
           pid = Process.wait
 
           if host = @children[pid]
             # Remove our host from the list of children, so the parallelization
             # continues working.
             @children.delete(pid)
             failures << host if $CHILD_STATUS.exitstatus != 0
             print "#{host} finished with exit code #{$CHILD_STATUS.exitstatus}\n"
           else
             $stderr.puts "Could not find host for PID #{pid} with status #{$CHILD_STATUS.exitstatus}"
           end
         rescue Errno::ECHILD
           # There are no children left, so just exit unless there are still
           # children left to do.
           next unless todo.empty?
 
           if failures.empty?
             puts "Finished"
             exit(0)
           else
             puts "Failed: #{failures.join(", ")}"
             exit(3)
           end
         end
       end
     end
   end
 
   def run_for_host(host)
     if options[:ping]
       out = %x{ping -c 1 #{host}}
       unless $CHILD_STATUS == 0
         $stderr.print "Could not contact #{host}\n"
         exit($CHILD_STATUS)
       end
     end
 
     require 'puppet/run'
     Puppet::Run.indirection.terminus_class = :rest
     port = Puppet[:puppetport]
     url = ["https://#{host}:#{port}", "production", "run", host].join('/')
 
     print "Triggering #{host}\n"
     begin
       run_options = {
         :tags => @tags,
         :background => ! options[:foreground],
         :ignoreschedules => options[:ignoreschedules]
       }
       run = Puppet::Run.indirection.save(Puppet::Run.new( run_options ), url)
       puts "Getting status"
       result = run.status
       puts "status is #{result}"
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      $stderr.puts "Host #{host} failed: #{detail}\n"
+      Puppet.log_exception(detail, "Host #{host} failed: #{detail}\n")
       exit(2)
     end
 
     case result
     when "success";
       exit(0)
     when "running"
       $stderr.puts "Host #{host} is already running"
       exit(3)
     else
       $stderr.puts "Host #{host} returned unknown answer '#{result}'"
       exit(12)
     end
   end
 
   def initialize(*args)
     super
     @hosts = []
     @classes = []
     @tags = []
   end
 
   def preinit
     [:INT, :TERM].each do |signal|
       Signal.trap(signal) do
         $stderr.puts "Cancelling"
         exit(1)
       end
     end
     options[:parallel] = 1
     options[:verbose] = true
     options[:fqdn] = true
     options[:ignoreschedules] = false
     options[:foreground] = false
   end
 
   def setup
     raise Puppet::Error.new("Puppet kick is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     else
       Puppet::Util::Log.level = :info
     end
 
     # Now parse the config
     Puppet.parse_config
 
     if Puppet[:node_terminus] == "ldap" and (options[:all] or @classes)
       if options[:all]
         @hosts = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn]).collect { |node| node.name }
         puts "all: #{@hosts.join(", ")}"
       else
         @hosts = []
         @classes.each do |klass|
           list = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn], :class => klass).collect { |node| node.name }
           puts "#{klass}: #{list.join(", ")}"
 
           @hosts += list
         end
       end
     elsif ! @classes.empty?
       $stderr.puts "You must be using LDAP to specify host classes"
       exit(24)
     end
 
     @children = {}
 
     # If we get a signal, then kill all of our children and get out.
     [:INT, :TERM].each do |signal|
       Signal.trap(signal) do
         Puppet.notice "Caught #{signal}; shutting down"
         @children.each do |pid, host|
           Process.kill("INT", pid)
         end
 
         waitall
 
         exit(1)
       end
     end
 
   end
 
 end
diff --git a/lib/puppet/application/master.rb b/lib/puppet/application/master.rb
index 553e27945..2b309de3e 100644
--- a/lib/puppet/application/master.rb
+++ b/lib/puppet/application/master.rb
@@ -1,239 +1,237 @@
 require 'puppet/application'
 
 class Puppet::Application::Master < Puppet::Application
 
   should_parse_config
   run_mode :master
 
   option("--debug", "-d")
   option("--verbose", "-v")
 
   # internal option, only to be used by ext/rack/config.ru
   option("--rack")
 
   option("--compile host",  "-c host") do |arg|
     options[:node] = arg
   end
 
   option("--logdest DEST",  "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
-      $stderr.puts detail.to_s
+      Puppet.log_exception(detail)
     end
   end
 
   option("--parseonly") do
     puts "--parseonly has been removed. Please use 'puppet parser validate <manifest>'"
     exit 1
   end
 
   def help
     <<-HELP
 
 puppet-master(8) -- The puppet master daemon
 ========
 
 SYNOPSIS
 --------
 The central puppet server. Functions as a certificate authority by
 default.
 
 
 USAGE
 -----
 puppet master [-D|--daemonize|--no-daemonize] [-d|--debug] [-h|--help]
   [-l|--logdest <file>|console|syslog] [-v|--verbose] [-V|--version]
   [--compile <node-name>]
 
 
 DESCRIPTION
 -----------
 This command starts an instance of puppet master, running as a daemon
 and using Ruby's built-in Webrick webserver. Puppet master can also be
 managed by other application servers; when this is the case, this
 executable is not used.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet master
 with '--genconfig'.
 
 * --daemonize:
   Send the process into the background. This is the default.
 
 * --no-daemonize:
   Do not send the process into the background.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to syslog, or the console if
   debugging or verbosity is enabled.
 
 * --verbose:
   Enable verbosity.
 
 * --version:
   Print the puppet version number and exit.
 
 * --compile:
   Compile a catalogue and output it in JSON from the puppet master. Uses
   facts contained in the $vardir/yaml/ directory to compile the catalog.
 
 
 EXAMPLE
 -------
   puppet master
 
 DIAGNOSTICS
 -----------
 
 When running as a standalone daemon, puppet master accepts the
 following signals:
 
 * SIGHUP:
   Restart the puppet master server.
 * SIGINT and SIGTERM:
   Shut down the puppet master server.
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def preinit
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     # Create this first-off, so we have ARGV
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
   end
 
   def run_command
     if options[:node]
       compile
     else
       main
     end
   end
 
   def compile
     Puppet::Util::Log.newdestination :console
     raise ArgumentError, "Cannot render compiled catalogs without pson support" unless Puppet.features.pson?
     begin
       unless catalog = Puppet::Resource::Catalog.indirection.find(options[:node])
         raise "Could not compile catalog for #{options[:node]}"
       end
 
       jj catalog.to_resource
     rescue => detail
       $stderr.puts detail
       exit(30)
     end
     exit(0)
   end
 
   def main
     require 'etc'
     require 'puppet/file_serving/content'
     require 'puppet/file_serving/metadata'
 
     # Make sure we've got a localhost ssl cert
     Puppet::SSL::Host.localhost
 
     # And now configure our server to *only* hit the CA for data, because that's
     # all it will have write access to.
     Puppet::SSL::Host.ca_location = :only if Puppet::SSL::CertificateAuthority.ca?
 
     if Puppet.features.root?
       begin
         Puppet::Util.chuser
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        $stderr.puts "Could not change user to #{Puppet[:user]}: #{detail}"
+        Puppet.log_exception(detail, "Could not change user to #{Puppet[:user]}: #{detail}")
         exit(39)
       end
     end
 
     unless options[:rack]
       require 'puppet/network/server'
       @daemon.server = Puppet::Network::Server.new()
       @daemon.daemonize if Puppet[:daemonize]
     else
       require 'puppet/network/http/rack'
       @app = Puppet::Network::HTTP::Rack.new()
     end
 
     Puppet.notice "Starting Puppet master version #{Puppet.version}"
 
     unless options[:rack]
       @daemon.start
     else
       return @app
     end
   end
 
   def setup
     raise Puppet::Error.new("Puppet master is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
 
     # Handle the logging settings.
     if options[:debug] or options[:verbose]
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
 
       unless Puppet[:daemonize] or options[:rack]
         Puppet::Util::Log.newdestination(:console)
         options[:setdest] = true
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet.settings.use :main, :master, :ssl, :metrics
 
     # Cache our nodes in yaml.  Currently not configurable.
     Puppet::Node.indirection.cache_class = :yaml
 
     # Configure all of the SSL stuff.
     if Puppet::SSL::CertificateAuthority.ca?
       Puppet::SSL::Host.ca_location = :local
       Puppet.settings.use :ca
       Puppet::SSL::CertificateAuthority.instance
     else
       Puppet::SSL::Host.ca_location = :none
     end
   end
 end
diff --git a/lib/puppet/application/queue.rb b/lib/puppet/application/queue.rb
index 2a9d3e7c3..6297b0743 100644
--- a/lib/puppet/application/queue.rb
+++ b/lib/puppet/application/queue.rb
@@ -1,184 +1,181 @@
 require 'puppet/application'
 require 'puppet/util'
 
 class Puppet::Application::Queue < Puppet::Application
   should_parse_config
 
   attr_accessor :daemon
 
   def preinit
     require 'puppet/daemon'
     @daemon = Puppet::Daemon.new
     @daemon.argv = ARGV.dup
 
     # Do an initial trap, so that cancels don't get a stack trace.
 
     # This exits with exit code 1
     Signal.trap(:INT) do
       $stderr.puts "Caught SIGINT; shutting down"
       exit(1)
     end
 
     # This is a normal shutdown, so code 0
     Signal.trap(:TERM) do
       $stderr.puts "Caught SIGTERM; shutting down"
       exit(0)
     end
 
     {
       :verbose => false,
       :debug => false
     }.each do |opt,val|
       options[opt] = val
     end
   end
 
   option("--debug","-d")
   option("--verbose","-v")
 
   def help
     <<-HELP
 
 puppet-queue(8) -- Queuing daemon for asynchronous storeconfigs
 ========
 
 SYNOPSIS
 --------
 Retrieves serialized storeconfigs records from a queue and processes
 them in order.
 
 
 USAGE
 -----
 puppet queue [-d|--debug] [-v|--verbose]
 
 
 DESCRIPTION
 -----------
 This application runs as a daemon and processes storeconfigs data,
 retrieving the data from a stomp server message queue and writing it to
 a database.
 
 For more information, including instructions for properly setting up
 your puppet master and message queue, see the documentation on setting
 up asynchronous storeconfigs at:
 http://projects.puppetlabs.com/projects/1/wiki/Using_Stored_Configuration
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'server' is a valid
 configuration parameter, so you can specify '--server <servername>' as
 an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet queue with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --help:
   Print this help message
 
 * --verbose:
   Turn on verbose reporting.
 
 * --version:
   Print the puppet version number and exit.
 
 
 EXAMPLE
 -------
     $ puppet queue
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
-      $stderr.puts detail.to_s
+      Puppet.log_exception(detail)
     end
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
-      $stderr.puts detail.to_s
+      Puppet.log_exception(detail)
     end
   end
 
   def main
     require 'puppet/indirector/catalog/queue' # provides Puppet::Indirector::Queue.subscribe
     Puppet.notice "Starting puppetqd #{Puppet.version}"
     Puppet::Resource::Catalog::Queue.subscribe do |catalog|
       # Once you have a Puppet::Resource::Catalog instance, passing it to save should suffice
       # to put it through to the database via its active_record indirector (which is determined
       # by the terminus_class = :active_record setting above)
       Puppet::Util.benchmark(:notice, "Processing queued catalog for #{catalog.name}") do
         begin
           Puppet::Resource::Catalog.indirection.save(catalog)
         rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          Puppet.err "Could not save queued catalog for #{catalog.name}: #{detail}"
+          Puppet.log_exception(detail, "Could not save queued catalog for #{catalog.name}: #{detail}")
         end
       end
     end
 
     Thread.list.each { |thread| thread.join }
   end
 
   # Handle the logging settings.
   def setup_logs
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def setup
     unless Puppet.features.stomp?
       raise ArgumentError, "Could not load the 'stomp' library, which must be present for queueing to work.  You must install the required library."
     end
 
     setup_logs
 
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     require 'puppet/resource/catalog'
     Puppet::Resource::Catalog.indirection.terminus_class = :store_configs
 
     daemon.daemonize if Puppet[:daemonize]
 
     # We want to make sure that we don't have a cache
     # class set up, because if storeconfigs is enabled,
     # we'll get a loop of continually caching the catalog
     # for storage again.
     Puppet::Resource::Catalog.indirection.cache_class = nil
   end
 end
diff --git a/lib/puppet/configurer.rb b/lib/puppet/configurer.rb
index dbf66c93f..f1b8a6627 100644
--- a/lib/puppet/configurer.rb
+++ b/lib/puppet/configurer.rb
@@ -1,257 +1,250 @@
 # The client for interacting with the puppetmaster config server.
 require 'sync'
 require 'timeout'
 require 'puppet/network/http_pool'
 require 'puppet/util'
 
 class Puppet::Configurer
   require 'puppet/configurer/fact_handler'
   require 'puppet/configurer/plugin_handler'
 
   include Puppet::Configurer::FactHandler
   include Puppet::Configurer::PluginHandler
 
   # For benchmarking
   include Puppet::Util
 
   attr_reader :compile_time
 
   # Provide more helpful strings to the logging that the Agent does
   def self.to_s
     "Puppet configuration client"
   end
 
   class << self
     # Puppetd should only have one instance running, and we need a way
     # to retrieve it.
     attr_accessor :instance
     include Puppet::Util
   end
 
   # How to lock instances of this class.
   def self.lockfile_path
     Puppet[:puppetdlockfile]
   end
 
   def clear
     @catalog.clear(true) if @catalog
     @catalog = nil
   end
 
   def execute_postrun_command
     execute_from_setting(:postrun_command)
   end
 
   def execute_prerun_command
     execute_from_setting(:prerun_command)
   end
 
   # Initialize and load storage
   def dostorage
       Puppet::Util::Storage.load
       @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
   rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Corrupt state file #{Puppet[:statefile]}: #{detail}"
-      begin
-        ::File.unlink(Puppet[:statefile])
-        retry
-      rescue => detail
-        raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
-      end
+    Puppet.log_exception(detail, "Removing corrupt state file #{Puppet[:statefile]}: #{detail}")
+    begin
+      ::File.unlink(Puppet[:statefile])
+      retry
+    rescue => detail
+      raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
+    end
   end
 
   # Just so we can specify that we are "the" instance.
   def initialize
     Puppet.settings.use(:main, :ssl, :agent)
 
     self.class.instance = self
     @running = false
     @splayed = false
   end
 
   # Prepare for catalog retrieval.  Downloads everything necessary, etc.
   def prepare(options)
     dostorage
     download_plugins unless options[:skip_plugin_download]
   end
 
   # Get the remote catalog, yo.  Returns nil if no catalog can be found.
   def retrieve_catalog(fact_options)
     fact_options ||= {}
     # First try it with no cache, then with the cache.
     unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
       if ! Puppet[:usecacheonfailure]
         Puppet.warning "Not using cache on failed catalog"
         return nil
       end
       result = retrieve_catalog_from_cache(fact_options)
     end
 
     return nil unless result
 
     convert_catalog(result, @duration)
   end
 
   # Convert a plain resource catalog into our full host catalog.
   def convert_catalog(result, duration)
     catalog = result.to_ral
     catalog.finalize
     catalog.retrieval_duration = duration
     catalog.write_class_file
     catalog.write_resource_file
     catalog
   end
 
   # Retrieve (optionally) and apply a catalog. If a catalog is passed in
   # the options, then apply that one, otherwise retrieve it.
   def retrieve_and_apply_catalog(options, fact_options)
     unless catalog = (options.delete(:catalog) || retrieve_catalog(fact_options))
       Puppet.err "Could not retrieve catalog; skipping run"
       return
     end
 
     report = options[:report]
     report.configuration_version = catalog.version
     report.environment = Puppet[:environment]
 
     benchmark(:notice, "Finished catalog run") do
       catalog.apply(options)
     end
 
     report.finalize_report
     report
   end
 
   # The code that actually runs the catalog.
   # This just passes any options on to the catalog,
   # which accepts :tags and :ignoreschedules.
   def run(options = {})
     options[:report] ||= Puppet::Transaction::Report.new("apply")
     report = options[:report]
 
     Puppet::Util::Log.newdestination(report)
     begin
       prepare(options)
 
       if Puppet::Resource::Catalog.indirection.terminus_class == :rest
         # This is a bit complicated.  We need the serialized and escaped facts,
         # and we need to know which format they're encoded in.  Thus, we
         # get a hash with both of these pieces of information.
         fact_options = facts_for_uploading
       end
 
       # set report host name now that we have the fact
       report.host = Puppet[:node_name_value]
 
       begin
         execute_prerun_command or return nil
         if retrieve_and_apply_catalog(options, fact_options)
           report.exit_status
         else
           nil
         end
       rescue SystemExit,NoMemoryError
         raise
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Failed to apply catalog: #{detail}"
+        Puppet.log_exception(detail, "Failed to apply catalog: #{detail}")
         return nil
       ensure
         execute_postrun_command or return nil
       end
     ensure
       # Make sure we forget the retained module_directories of any autoload
       # we might have used.
       Thread.current[:env_module_directories] = nil
     end
   ensure
     Puppet::Util::Log.close(report)
     send_report(report)
   end
 
   def send_report(report)
     puts report.summary if Puppet[:summarize]
     save_last_run_summary(report)
     Puppet::Transaction::Report.indirection.save(report) if Puppet[:report]
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not send report: #{detail}"
+    Puppet.log_exception(detail, "Could not send report: #{detail}")
   end
 
   def save_last_run_summary(report)
     last_run = Puppet.settings.setting(:lastrunfile)
     last_run.create = true # force file creation
 
     resource = last_run.to_resource
     resource[:content] = YAML.dump(report.raw_summary)
 
     catalog = Puppet::Resource::Catalog.new("last_run_file")
     catalog.add_resource(resource)
     ral = catalog.to_ral
     ral.host_config = false
     ral.apply
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not save last run local report: #{detail}"
+    Puppet.log_exception(detail, "Could not save last run local report: #{detail}")
   end
 
   private
 
   def self.timeout
     timeout = Puppet[:configtimeout]
     case timeout
     when String
       if timeout =~ /^\d+$/
         timeout = Integer(timeout)
       else
         raise ArgumentError, "Configuration timeout must be an integer"
       end
     when Integer # nothing
     else
       raise ArgumentError, "Configuration timeout must be an integer"
     end
 
     timeout
   end
 
   def execute_from_setting(setting)
     return true if (command = Puppet[setting]) == ""
 
     begin
       Puppet::Util::Execution.execute([command])
       true
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not run command from #{setting}: #{detail}"
+      Puppet.log_exception(detail, "Could not run command from #{setting}: #{detail}")
       false
     end
   end
 
   def retrieve_catalog_from_cache(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_terminus => true))
     end
     Puppet.notice "Using cached catalog"
     result
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not retrieve catalog from cache: #{detail}"
+    Puppet.log_exception(detail, "Could not retrieve catalog from cache: #{detail}")
     return nil
   end
 
   def retrieve_new_catalog(fact_options)
     result = nil
     @duration = thinmark do
       result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], fact_options.merge(:ignore_cache => true))
     end
     result
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Could not retrieve catalog from remote server: #{detail}"
+    Puppet.log_exception(detail, "Could not retrieve catalog from remote server: #{detail}")
     return nil
   end
 end
diff --git a/lib/puppet/configurer/downloader.rb b/lib/puppet/configurer/downloader.rb
index 54075ee7e..de116259e 100644
--- a/lib/puppet/configurer/downloader.rb
+++ b/lib/puppet/configurer/downloader.rb
@@ -1,82 +1,81 @@
 require 'puppet/configurer'
 require 'puppet/resource/catalog'
 
 class Puppet::Configurer::Downloader
   attr_reader :name, :path, :source, :ignore
 
   # Determine the timeout value to use.
   def self.timeout
     timeout = Puppet[:configtimeout]
     case timeout
     when String
       if timeout =~ /^\d+$/
         timeout = Integer(timeout)
       else
         raise ArgumentError, "Configuration timeout must be an integer"
       end
     when Integer # nothing
     else
       raise ArgumentError, "Configuration timeout must be an integer"
     end
 
     timeout
   end
 
   # Evaluate our download, returning the list of changed values.
   def evaluate
     Puppet.info "Retrieving #{name}"
 
     files = []
     begin
       Timeout.timeout(self.class.timeout) do
         catalog.apply do |trans|
           trans.changed?.find_all do |resource|
             yield resource if block_given?
             files << resource[:path]
           end
         end
       end
     rescue Puppet::Error, Timeout::Error => detail
-      puts detail.backtrace if Puppet[:debug]
-      Puppet.err "Could not retrieve #{name}: #{detail}"
+      Puppet.log_exception(detail, "Could not retrieve #{name}: #{detail}")
     end
 
     files
   end
 
   def initialize(name, path, source, ignore = nil)
     @name, @path, @source, @ignore = name, path, source, ignore
   end
 
   def catalog
     catalog = Puppet::Resource::Catalog.new
     catalog.host_config = false
     catalog.add_resource(file)
     catalog
   end
 
   def file
     args = default_arguments.merge(:path => path, :source => source)
     args[:ignore] = ignore.split if ignore
     Puppet::Type.type(:file).new(args)
   end
 
   private
 
   require 'sys/admin' if Puppet.features.microsoft_windows?
 
   def default_arguments
     {
       :path => path,
       :recurse => true,
       :source => source,
       :tag => name,
       :owner => Puppet.features.microsoft_windows? ? Sys::Admin.get_login : Process.uid,
       :group => Puppet.features.microsoft_windows? ? 'S-1-0-0' : Process.gid,
       :purge => true,
       :force => true,
       :backup => false,
       :noop => false
     }
   end
 end
diff --git a/lib/puppet/configurer/fact_handler.rb b/lib/puppet/configurer/fact_handler.rb
index 7f720d7dc..6027732ce 100644
--- a/lib/puppet/configurer/fact_handler.rb
+++ b/lib/puppet/configurer/fact_handler.rb
@@ -1,42 +1,43 @@
 require 'puppet/indirector/facts/facter'
 
 require 'puppet/configurer/downloader'
 
 # Break out the code related to facts.  This module is
 # just included into the agent, but having it here makes it
 # easier to test.
 module Puppet::Configurer::FactHandler
   def find_facts
     # This works because puppet agent configures Facts to use 'facter' for
     # finding facts and the 'rest' terminus for caching them.  Thus, we'll
     # compile them and then "cache" them on the server.
     begin
       facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
       unless Puppet[:node_name_fact].empty?
         Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
         facts.name = Puppet[:node_name_value]
       end
       facts
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Could not retrieve local facts: #{detail}"
+      message = "Could not retrieve local facts: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
   end
 
   def facts_for_uploading
     facts = find_facts
     #format = facts.class.default_format
 
     if facts.support_format?(:b64_zlib_yaml)
       format = :b64_zlib_yaml
     else
       format = :yaml
     end
 
     text = facts.render(format)
 
     {:facts_format => format, :facts => CGI.escape(text)}
   end
 end
diff --git a/lib/puppet/face/catalog.rb b/lib/puppet/face/catalog.rb
index efd4ee7f7..ae2dadc29 100644
--- a/lib/puppet/face/catalog.rb
+++ b/lib/puppet/face/catalog.rb
@@ -1,131 +1,130 @@
 require 'puppet/indirector/face'
 
 Puppet::Indirector::Face.define(:catalog, '0.0.1') do
   copyright "Puppet Labs", 2011
   license   "Apache 2 license; see COPYING"
 
   summary "Compile, save, view, and convert catalogs."
   description <<-'EOT'
     This subcommand deals with catalogs, which are compiled per-node artifacts
     generated from a set of Puppet manifests. By default, it interacts with the
     compiling subsystem and compiles a catalog using the default manifest and
     `certname`, but you can change the source of the catalog with the
     `--terminus` option. You can also choose to print any catalog in 'dot'
     format (for easy graph viewing with OmniGraffle or Graphviz) with
     '--render-as dot'.
   EOT
   short_description <<-'EOT'
     This subcommand deals with catalogs, which are compiled per-node artifacts
     generated from a set of Puppet manifests. By default, it interacts with the
     compiling subsystem and compiles a catalog using the default manifest and
     `certname`; use the `--terminus` option to change the source of the catalog.
   EOT
 
   get_action(:destroy).summary "Invalid for this subcommand."
   get_action(:search).summary "Invalid for this subcommand."
   find = get_action(:find)
   find.summary "Retrieve the catalog for a node."
   find.arguments "<certname>"
   find.returns <<-'EOT'
     A serialized catalog. When used from the Ruby API, returns a
     Puppet::Resource::Catalog object.
   EOT
 
   action(:apply) do
     summary "Find and apply a catalog."
     description <<-'EOT'
       Finds and applies a catalog. This action takes no arguments, but
       the source of the catalog can be managed with the `--terminus` option.
     EOT
     returns <<-'EOT'
       Nothing. When used from the Ruby API, returns a
       Puppet::Transaction::Report object.
     EOT
     examples <<-'EOT'
       Apply the locally cached catalog:
 
       $ puppet catalog apply --terminus yaml
 
       Retrieve a catalog from the master and apply it, in one step:
 
       $ puppet catalog apply --terminus rest
 
       From `secret_agent.rb` (API example):
 
           # ...
           Puppet::Face[:catalog, '0.0.1'].download
           # (Termini are singletons; catalog.download has a side effect of
           # setting the catalog terminus to yaml)
           report  = Puppet::Face[:catalog, '0.0.1'].apply
           # ...
     EOT
 
     when_invoked do |options|
       catalog = Puppet::Face[:catalog, "0.0.1"].find(Puppet[:certname]) or raise "Could not find catalog for #{Puppet[:certname]}"
       catalog = catalog.to_ral
 
       report = Puppet::Transaction::Report.new("apply")
       report.configuration_version = catalog.version
       report.environment = Puppet[:environment]
 
       Puppet::Util::Log.newdestination(report)
 
       begin
         benchmark(:notice, "Finished catalog run") do
           catalog.apply(:report => report)
         end
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Failed to apply catalog: #{detail}"
+        Puppet.log_exception(detail, "Failed to apply catalog: #{detail}")
       end
 
       report.finalize_report
       report
     end
   end
 
   action(:download) do
     summary "Download this node's catalog from the puppet master server."
     description <<-'EOT'
       Retrieves a catalog from the puppet master and saves it to the local yaml
       cache. This action always contacts the puppet master and will ignore
       alternate termini.
 
       The saved catalog can be used in any subsequent catalog action by specifying
       '--terminus yaml' for that action.
     EOT
     returns "Nothing."
     notes <<-'EOT'
       When used from the Ruby API, this action has a side effect of leaving
       Puppet::Resource::Catalog.indirection.terminus_class set to yaml. The
       terminus must be explicitly re-set for subsequent catalog actions.
     EOT
     examples <<-'EOT'
       Retrieve and store a catalog:
 
       $ puppet catalog download
 
       From `secret_agent.rb` (API example):
 
           Puppet::Face[:plugin, '0.0.1'].download
           Puppet::Face[:facts, '0.0.1'].upload
           Puppet::Face[:catalog, '0.0.1'].download
           # ...
     EOT
     when_invoked do |options|
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
       Puppet::Resource::Catalog.indirection.cache_class = nil
       catalog = nil
       retrieval_duration = thinmark do
         catalog = Puppet::Face[:catalog, '0.0.1'].find(Puppet[:certname])
       end
       catalog.retrieval_duration = retrieval_duration
       catalog.write_class_file
 
       Puppet::Resource::Catalog.indirection.terminus_class = :yaml
       Puppet::Face[:catalog, "0.0.1"].save(catalog)
       Puppet.notice "Saved catalog for #{Puppet[:certname]} to yaml"
       nil
     end
   end
 end
diff --git a/lib/puppet/face/report.rb b/lib/puppet/face/report.rb
index 22737103c..55288cc42 100644
--- a/lib/puppet/face/report.rb
+++ b/lib/puppet/face/report.rb
@@ -1,56 +1,54 @@
 require 'puppet/indirector/face'
 
 Puppet::Indirector::Face.define(:report, '0.0.1') do
   copyright "Puppet Labs", 2011
   license   "Apache 2 license; see COPYING"
 
   summary "Create, display, and submit reports."
 
   get_action(:find).summary "Invalid for this face."
   get_action(:search).summary "Invalid for this face."
   get_action(:destroy).summary "Invalid for this face."
   save = get_action(:save)
   save.summary "API only: submit a report."
   save.arguments "<report>"
   save.returns "Nothing."
   save.examples <<-'EOT'
     From the implementation of `puppet report submit` (API example):
 
         begin
           Puppet::Transaction::Report.indirection.terminus_class = :rest
           Puppet::Face[:report, "0.0.1"].save(report)
           Puppet.notice "Uploaded report for #{report.name}"
         rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          Puppet.err "Could not send report: #{detail}"
+          Puppet.log_exception(detail, "Could not send report: #{detail}")
         end
   EOT
 
   action(:submit) do
     summary "API only: submit a report with error handling."
     description <<-'EOT'
       API only: Submits a report to the puppet master. This action is
       essentially a shortcut and wrapper for the `save` action with the `rest`
       terminus, and provides additional details in the event of a failure.
     EOT
     arguments "<report>"
     examples <<-'EOT'
       From secret_agent.rb (API example):
 
           # ...
           report  = Puppet::Face[:catalog, '0.0.1'].apply
           Puppet::Face[:report, '0.0.1'].submit(report)
           return report
     EOT
     when_invoked do |report, options|
       begin
         Puppet::Transaction::Report.indirection.terminus_class = :rest
         Puppet::Face[:report, "0.0.1"].save(report)
         Puppet.notice "Uploaded report for #{report.name}"
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not send report: #{detail}"
+        Puppet.log_exception(detail, "Could not send report: #{detail}")
       end
     end
   end
 end
diff --git a/lib/puppet/file_bucket/dipper.rb b/lib/puppet/file_bucket/dipper.rb
index 4adab5df0..a4cc9ed32 100644
--- a/lib/puppet/file_bucket/dipper.rb
+++ b/lib/puppet/file_bucket/dipper.rb
@@ -1,107 +1,108 @@
 require 'puppet/file_bucket'
 require 'puppet/file_bucket/file'
 require 'puppet/indirector/request'
 
 class Puppet::FileBucket::Dipper
   # This is a transitional implementation that uses REST
   # to access remote filebucket files.
 
   attr_accessor :name
 
   # Create our bucket client
   def initialize(hash = {})
     # Emulate the XMLRPC client
     server      = hash[:Server]
     port        = hash[:Port] || Puppet[:masterport]
     environment = Puppet[:environment]
 
     if hash.include?(:Path)
       @local_path = hash[:Path]
       @rest_path  = nil
     else
       @local_path = nil
       @rest_path = "https://#{server}:#{port}/#{environment}/file_bucket_file/"
     end
   end
 
   def local?
     !! @local_path
   end
 
   # Back up a file to our bucket
   def backup(file)
     raise(ArgumentError, "File #{file} does not exist") unless ::File.exist?(file)
     contents = IO.binread(file)
     begin
       file_bucket_file = Puppet::FileBucket::File.new(contents, :bucket_path => @local_path)
       files_original_path = absolutize_path(file)
       dest_path = "#{@rest_path}#{file_bucket_file.name}/#{files_original_path}"
       file_bucket_path = "#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"
 
       # Make a HEAD request for the file so that we don't waste time
       # uploading it if it already exists in the bucket.
       unless Puppet::FileBucket::File.indirection.head(file_bucket_path)
         Puppet::FileBucket::File.indirection.save(file_bucket_file, dest_path)
       end
 
       return file_bucket_file.checksum_data
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Could not back up #{file}: #{detail}"
+      message = "Could not back up #{file}: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
   end
 
   # Retrieve a file by sum.
   def getfile(sum)
     source_path = "#{@rest_path}md5/#{sum}"
     file_bucket_file = Puppet::FileBucket::File.indirection.find(source_path, :bucket_path => @local_path)
 
     raise Puppet::Error, "File not found" unless file_bucket_file
     file_bucket_file.to_s
   end
 
   # Restore the file
   def restore(file,sum)
     restore = true
     if FileTest.exists?(file)
       cursum = Digest::MD5.hexdigest(IO.binread(file))
 
       # if the checksum has changed...
       # this might be extra effort
       if cursum == sum
         restore = false
       end
     end
 
     if restore
       if newcontents = getfile(sum)
         tmp = ""
         newsum = Digest::MD5.hexdigest(newcontents)
         changed = nil
         if FileTest.exists?(file) and ! FileTest.writable?(file)
           changed = ::File.stat(file).mode
           ::File.chmod(changed | 0200, file)
         end
         ::File.open(file, ::File::WRONLY|::File::TRUNC|::File::CREAT) { |of|
           of.binmode
           of.print(newcontents)
         }
         ::File.chmod(changed, file) if changed
       else
         Puppet.err "Could not find file with checksum #{sum}"
         return nil
       end
       return newsum
     else
       return nil
     end
   end
 
   private
   def absolutize_path( path )
     require 'pathname'
     Pathname.new(path).realpath
   end
 
 end
 
diff --git a/lib/puppet/file_serving/configuration.rb b/lib/puppet/file_serving/configuration.rb
index c9ecb5aa4..b600bbd69 100644
--- a/lib/puppet/file_serving/configuration.rb
+++ b/lib/puppet/file_serving/configuration.rb
@@ -1,121 +1,120 @@
 require 'monitor'
 require 'puppet'
 require 'puppet/file_serving'
 require 'puppet/file_serving/mount'
 require 'puppet/file_serving/mount/file'
 require 'puppet/file_serving/mount/modules'
 require 'puppet/file_serving/mount/plugins'
 
 class Puppet::FileServing::Configuration
   require 'puppet/file_serving/configuration/parser'
 
   extend MonitorMixin
 
   def self.configuration
     synchronize do
       @configuration ||= new
     end
   end
 
   Mount = Puppet::FileServing::Mount
 
   private_class_method  :new
 
   attr_reader :mounts
   #private :mounts
 
   # Find the right mount.  Does some shenanigans to support old-style module
   # mounts.
   def find_mount(mount_name, environment)
     # Reparse the configuration if necessary.
     readconfig
 
     if mount = mounts[mount_name]
       return mount
     end
 
     if environment.module(mount_name)
       Puppet.deprecation_warning "DEPRECATION NOTICE: Files found in modules without specifying 'modules' in file path will be deprecated in the next major release.  Please fix module '#{mount_name}' when no 0.24.x clients are present"
       return mounts["modules"]
     end
 
     # This can be nil.
     mounts[mount_name]
   end
 
   def initialize
     @mounts = {}
     @config_file = nil
 
     # We don't check to see if the file is modified the first time,
     # because we always want to parse at first.
     readconfig(false)
   end
 
   # Is a given mount available?
   def mounted?(name)
     @mounts.include?(name)
   end
 
   # Split the path into the separate mount point and path.
   def split_path(request)
     # Reparse the configuration if necessary.
     readconfig
 
     mount_name, path = request.key.split(File::Separator, 2)
 
     raise(ArgumentError, "Cannot find file: Invalid path '#{mount_name}'") unless mount_name =~ %r{^[-\w]+$}
 
     return nil unless mount = find_mount(mount_name, request.environment)
     if mount.name == "modules" and mount_name != "modules"
       # yay backward-compatibility
       path = "#{mount_name}/#{path}"
     end
 
     if path == ""
       path = nil
     elsif path
       # Remove any double slashes that might have occurred
       path = path.gsub(/\/+/, "/")
     end
 
     return mount, path
   end
 
   def umount(name)
     @mounts.delete(name) if @mounts.include? name
   end
 
   private
 
   def mk_default_mounts
     @mounts["modules"] ||= Mount::Modules.new("modules")
     @mounts["modules"].allow('*') if @mounts["modules"].empty?
     @mounts["plugins"] ||= Mount::Plugins.new("plugins")
     @mounts["plugins"].allow('*') if @mounts["plugins"].empty?
   end
 
   # Read the configuration file.
   def readconfig(check = true)
     config = Puppet[:fileserverconfig]
 
     return unless FileTest.exists?(config)
 
     @parser ||= Puppet::FileServing::Configuration::Parser.new(config)
 
     return if check and ! @parser.changed?
 
     # Don't assign the mounts hash until we're sure the parsing succeeded.
     begin
       newmounts = @parser.parse
       @mounts = newmounts
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Error parsing fileserver configuration: #{detail}; using old configuration"
+      Puppet.log_exception(detail, "Error parsing fileserver configuration: #{detail}; using old configuration")
     end
 
   ensure
     # Make sure we've got our plugins and modules.
     mk_default_mounts
   end
 end
diff --git a/lib/puppet/indirector/catalog/compiler.rb b/lib/puppet/indirector/catalog/compiler.rb
index 19f83861a..352c9a312 100644
--- a/lib/puppet/indirector/catalog/compiler.rb
+++ b/lib/puppet/indirector/catalog/compiler.rb
@@ -1,153 +1,154 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/code'
 require 'yaml'
 
 class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   desc "Puppet's catalog compilation interface, and its back-end is
     Puppet's compiler"
 
   include Puppet::Util
 
   attr_accessor :code
 
   def extract_facts_from_request(request)
     return unless text_facts = request.options[:facts]
     raise ArgumentError, "Facts but no fact format provided for #{request.name}" unless format = request.options[:facts_format]
 
     # If the facts were encoded as yaml, then the param reconstitution system
     # in Network::HTTP::Handler will automagically deserialize the value.
     if text_facts.is_a?(Puppet::Node::Facts)
       facts = text_facts
     else
       facts = Puppet::Node::Facts.convert_from(format, text_facts)
     end
     facts.add_timestamp
     Puppet::Node::Facts.indirection.save(facts)
   end
 
   # Compile a node's catalog.
   def find(request)
     extract_facts_from_request(request)
 
     node = node_from_request(request)
 
     if catalog = compile(node)
       return catalog
     else
       # This shouldn't actually happen; we should either return
       # a config or raise an exception.
       return nil
     end
   end
 
   # filter-out a catalog to remove exported resources
   def filter(catalog)
     return catalog.filter { |r| r.virtual? } if catalog.respond_to?(:filter)
     catalog
   end
 
   def initialize
     set_server_facts
   end
 
   # Is our compiler part of a network, or are we just local?
   def networked?
     Puppet.run_mode.master?
   end
 
   private
 
   # Add any extra data necessary to the node.
   def add_node_data(node)
     # Merge in our server-side facts, so they can be used during compilation.
     node.merge(@server_facts)
   end
 
   # Compile the actual catalog.
   def compile(node)
     str = "Compiled catalog for #{node.name}"
     str += " in environment #{node.environment}" if node.environment
     config = nil
 
     loglevel = networked? ? :notice : :none
 
     benchmark(loglevel, str) do
       begin
         config = Puppet::Parser::Compiler.compile(node)
       rescue Puppet::Error => detail
         Puppet.err(detail.to_s) if networked?
         raise
       end
     end
 
     config
   end
 
   # Turn our host name into a node object.
   def find_node(name)
     begin
       return nil unless node = Puppet::Node.indirection.find(name)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Failed when searching for node #{name}: #{detail}"
+      message = "Failed when searching for node #{name}: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
 
 
     # Add any external data to the node.
     add_node_data(node)
 
     node
   end
 
   # Extract the node from the request, or use the request
   # to find the node.
   def node_from_request(request)
     if node = request.options[:use_node]
       return node
     end
 
     # We rely on our authorization system to determine whether the connected
     # node is allowed to compile the catalog's node referenced by key.
     # By default the REST authorization system makes sure only the connected node
     # can compile his catalog.
     # This allows for instance monitoring systems or puppet-load to check several
     # node's catalog with only one certificate and a modification to auth.conf 
     # If no key is provided we can only compile the currently connected node.
     name = request.key || request.node
     if node = find_node(name)
       return node
     end
 
     raise ArgumentError, "Could not find node '#{name}'; cannot compile"
   end
 
   # Initialize our server fact hash; we add these to each client, and they
   # won't change while we're running, so it's safe to cache the values.
   def set_server_facts
     @server_facts = {}
 
     # Add our server version to the fact list
     @server_facts["serverversion"] = Puppet.version.to_s
 
     # And then add the server name and IP
     {"servername" => "fqdn",
       "serverip" => "ipaddress"
     }.each do |var, fact|
       if value = Facter.value(fact)
         @server_facts[var] = value
       else
         Puppet.warning "Could not retrieve fact #{fact}"
       end
     end
 
     if @server_facts["servername"].nil?
       host = Facter.value(:hostname)
       if domain = Facter.value(:domain)
         @server_facts["servername"] = [host, domain].join(".")
       else
         @server_facts["servername"] = host
       end
     end
   end
 end
diff --git a/lib/puppet/indirector/face.rb b/lib/puppet/indirector/face.rb
index adb6b688b..27265beba 100644
--- a/lib/puppet/indirector/face.rb
+++ b/lib/puppet/indirector/face.rb
@@ -1,137 +1,138 @@
 require 'puppet/face'
 
 class Puppet::Indirector::Face < Puppet::Face
   option "--terminus TERMINUS" do
     summary "The indirector terminus to use."
     description <<-EOT
       Indirector faces expose indirected subsystems of Puppet. These
       subsystems are each able to retrieve and alter a specific type of data
       (with the familiar actions of `find`, `search`, `save`, and `destroy`)
       from an arbitrary number of pluggable backends. In Puppet parlance,
       these backends are called terminuses.
 
       Almost all indirected subsystems have a `rest` terminus that interacts
       with the puppet master's data. Most of them have additional terminuses
       for various local data models, which are in turn used by the indirected
       subsystem on the puppet master whenever it receives a remote request.
 
       The terminus for an action is often determined by context, but
       occasionally needs to be set explicitly. See the "Notes" section of this
       face's manpage for more details.
     EOT
 
     before_action do |action, args, options|
       set_terminus(options[:terminus])
     end
 
     after_action do |action, args, options|
       indirection.reset_terminus_class
     end
   end
 
   def self.indirections
     Puppet::Indirector::Indirection.instances.collect { |t| t.to_s }.sort
   end
 
   def self.terminus_classes(indirection)
     Puppet::Indirector::Terminus.terminus_classes(indirection.to_sym).collect { |t| t.to_s }.sort
   end
 
   def call_indirection_method(method, key, options)
     begin
       result = indirection.__send__(method, key, options)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise "Could not call '#{method}' on '#{indirection_name}': #{detail}"
+      message = "Could not call '#{method}' on '#{indirection_name}': #{detail}"
+      Puppet.log_exception(detail, message)
+      raise message
     end
 
     return result
   end
 
   option "--extra HASH" do
     summary "Extra arguments to pass to the indirection request"
     description <<-end
       A terminus can take additional arguments to refine the operation, which
       are passed as an arbitrary hash to the back-end.  Anything passed as
       the extra value is just send direct to the back-end.
     end
     default_to do Hash.new end
   end
 
   action :destroy do
     summary "Delete an object."
     arguments "<key>"
     when_invoked {|key, options| call_indirection_method :destroy, key, options[:extra] }
   end
 
   action :find do
     summary "Retrieve an object by name."
     arguments "<key>"
     when_invoked {|key, options| call_indirection_method :find, key, options[:extra] }
   end
 
   action :save do
     summary "API only: create or overwrite an object."
     arguments "<object>"
     description <<-EOT
       API only: create or overwrite an object. As the Faces framework does not
       currently accept data from STDIN, save actions cannot currently be invoked
       from the command line.
     EOT
     when_invoked {|key, options| call_indirection_method :save, key, options[:extra] }
   end
 
   action :search do
     summary "Search for an object or retrieve multiple objects."
     arguments "<query>"
     when_invoked {|key, options| call_indirection_method :search, key, options[:extra] }
   end
 
   # Print the configuration for the current terminus class
   action :info do
     summary "Print the default terminus class for this face."
     description <<-EOT
       Prints the default terminus class for this subcommand. Note that different
       run modes may have different default termini; when in doubt, specify the
       run mode with the '--mode' option.
     EOT
 
     when_invoked do |options|
       if t = indirection.terminus_class
         "Run mode '#{Puppet.run_mode.name}': #{t}"
       else
         "No default terminus class for run mode '#{Puppet.run_mode.name}'"
       end
     end
   end
 
   attr_accessor :from
 
   def indirection_name
     @indirection_name || name.to_sym
   end
 
   # Here's your opportunity to override the indirection name.  By default it
   # will be the same name as the face.
   def set_indirection_name(name)
     @indirection_name = name
   end
 
   # Return an indirection associated with a face, if one exists;
   # One usually does.
   def indirection
     unless @indirection
       @indirection = Puppet::Indirector::Indirection.instance(indirection_name)
       @indirection or raise "Could not find terminus for #{indirection_name}"
     end
     @indirection
   end
 
   def set_terminus(from)
     begin
       indirection.terminus_class = from
     rescue => detail
       raise "Could not set '#{indirection.name}' terminus to '#{from}' (#{detail}); valid terminus types are #{self.class.terminus_classes(indirection.name).join(", ") }"
     end
   end
 end
diff --git a/lib/puppet/indirector/indirection.rb b/lib/puppet/indirector/indirection.rb
index 7296be2b9..92b3a1b45 100644
--- a/lib/puppet/indirector/indirection.rb
+++ b/lib/puppet/indirector/indirection.rb
@@ -1,324 +1,323 @@
 require 'puppet/util/docs'
 require 'puppet/indirector/envelope'
 require 'puppet/indirector/request'
 require 'puppet/util/instrumentation/instrumentable'
 
 # The class that connects functional classes with their different collection
 # back-ends.  Each indirection has a set of associated terminus classes,
 # each of which is a subclass of Puppet::Indirector::Terminus.
 class Puppet::Indirector::Indirection
   include Puppet::Util::Docs
   extend Puppet::Util::Instrumentation::Instrumentable
 
   probe :find, :label => Proc.new { |parent, key, *args| "find_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :save, :label => Proc.new { |parent, key, *args| "save_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :search, :label => Proc.new { |parent, key, *args| "search_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
   probe :destroy, :label => Proc.new { |parent, key, *args| "destroy_#{parent.name}_#{parent.terminus_class}" }, :data => Proc.new { |parent, key, *args| { :key => key }}
 
   @@indirections = []
 
   # Find an indirection by name.  This is provided so that Terminus classes
   # can specifically hook up with the indirections they are associated with.
   def self.instance(name)
     @@indirections.find { |i| i.name == name }
   end
 
   # Return a list of all known indirections.  Used to generate the
   # reference.
   def self.instances
     @@indirections.collect { |i| i.name }
   end
 
   # Find an indirected model by name.  This is provided so that Terminus classes
   # can specifically hook up with the indirections they are associated with.
   def self.model(name)
     return nil unless match = @@indirections.find { |i| i.name == name }
     match.model
   end
 
   attr_accessor :name, :model
 
   attr_reader :termini
 
   # Create and return our cache terminus.
   def cache
     raise(Puppet::DevError, "Tried to cache when no cache class was set") unless cache_class
     terminus(cache_class)
   end
 
   # Should we use a cache?
   def cache?
     cache_class ? true : false
   end
 
   attr_reader :cache_class
   # Define a terminus class to be used for caching.
   def cache_class=(class_name)
     validate_terminus_class(class_name) if class_name
     @cache_class = class_name
   end
 
   # This is only used for testing.
   def delete
     @@indirections.delete(self) if @@indirections.include?(self)
   end
 
   # Set the time-to-live for instances created through this indirection.
   def ttl=(value)
     raise ArgumentError, "Indirection TTL must be an integer" unless value.is_a?(Fixnum)
     @ttl = value
   end
 
   # Default to the runinterval for the ttl.
   def ttl
     @ttl ||= Puppet[:runinterval].to_i
   end
 
   # Calculate the expiration date for a returned instance.
   def expiration
     Time.now + ttl
   end
 
   # Generate the full doc string.
   def doc
     text = ""
 
     text += scrub(@doc) + "\n\n" if @doc
 
     if s = terminus_setting
       text += "* **Terminus Setting**: #{terminus_setting}"
     end
 
     text
   end
 
   def initialize(model, name, options = {})
     @model = model
     @name = name
     @termini = {}
 
     @cache_class = nil
     @terminus_class = nil
 
     raise(ArgumentError, "Indirection #{@name} is already defined") if @@indirections.find { |i| i.name == @name }
     @@indirections << self
 
     if mod = options[:extend]
       extend(mod)
       options.delete(:extend)
     end
 
     # This is currently only used for cache_class and terminus_class.
     options.each do |name, value|
       begin
         send(name.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "#{name} is not a valid Indirection parameter"
       end
     end
   end
 
   # Set up our request object.
   def request(*args)
     Puppet::Indirector::Request.new(self.name, *args)
   end
 
   # Return the singleton terminus for this indirection.
   def terminus(terminus_name = nil)
     # Get the name of the terminus.
     raise Puppet::DevError, "No terminus specified for #{self.name}; cannot redirect" unless terminus_name ||= terminus_class
 
     termini[terminus_name] ||= make_terminus(terminus_name)
   end
 
   # This can be used to select the terminus class.
   attr_accessor :terminus_setting
 
   # Determine the terminus class.
   def terminus_class
     unless @terminus_class
       if setting = self.terminus_setting
         self.terminus_class = Puppet.settings[setting].to_sym
       else
         raise Puppet::DevError, "No terminus class nor terminus setting was provided for indirection #{self.name}"
       end
     end
     @terminus_class
   end
 
   def reset_terminus_class
     @terminus_class = nil
   end
 
   # Specify the terminus class to use.
   def terminus_class=(klass)
     validate_terminus_class(klass)
     @terminus_class = klass
   end
 
   # This is used by terminus_class= and cache=.
   def validate_terminus_class(terminus_class)
     raise ArgumentError, "Invalid terminus name #{terminus_class.inspect}" unless terminus_class and terminus_class.to_s != ""
     unless Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
       raise ArgumentError, "Could not find terminus #{terminus_class} for indirection #{self.name}"
     end
   end
 
   # Expire a cached object, if one is cached.  Note that we don't actually
   # remove it, we expire it and write it back out to disk.  This way people
   # can still use the expired object if they want.
   def expire(key, *args)
     request = request(:expire, key, *args)
 
     return nil unless cache?
 
     return nil unless instance = cache.find(request(:find, key, *args))
 
     Puppet.info "Expiring the #{self.name} cache of #{instance.name}"
 
     # Set an expiration date in the past
     instance.expiration = Time.now - 60
 
     cache.save(request(:save, instance, *args))
   end
 
   # Search for an instance in the appropriate terminus, caching the
   # results if caching is configured..
   def find(key, *args)
     request = request(:find, key, *args)
     terminus = prepare(request)
 
     if result = find_in_cache(request)
       return result
     end
 
     # Otherwise, return the result from the terminus, caching if appropriate.
     if ! request.ignore_terminus? and result = terminus.find(request)
       result.expiration ||= self.expiration if result.respond_to?(:expiration)
       if cache? and request.use_cache?
         Puppet.info "Caching #{self.name} for #{request.key}"
         cache.save request(:save, result, *args)
       end
 
       return terminus.respond_to?(:filter) ? terminus.filter(result) : result
     end
 
     nil
   end
 
   # Search for an instance in the appropriate terminus, and return a
   # boolean indicating whether the instance was found.
   def head(key, *args)
     request = request(:head, key, *args)
     terminus = prepare(request)
 
     # Look in the cache first, then in the terminus.  Force the result
     # to be a boolean.
     !!(find_in_cache(request) || terminus.head(request))
   end
 
   def find_in_cache(request)
     # See if our instance is in the cache and up to date.
     return nil unless cache? and ! request.ignore_cache? and cached = cache.find(request)
     if cached.expired?
       Puppet.info "Not using expired #{self.name} for #{request.key} from cache; expired at #{cached.expiration}"
       return nil
     end
 
     Puppet.debug "Using cached #{self.name} for #{request.key}"
     cached
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Cached #{self.name} for #{request.key} failed: #{detail}"
+    Puppet.log_exception(detail, "Cached #{self.name} for #{request.key} failed: #{detail}")
     nil
   end
 
   # Remove something via the terminus.
   def destroy(key, *args)
     request = request(:destroy, key, *args)
     terminus = prepare(request)
 
     result = terminus.destroy(request)
 
     if cache? and cached = cache.find(request(:find, key, *args))
       # Reuse the existing request, since it's equivalent.
       cache.destroy(request)
     end
 
     result
   end
 
   # Search for more than one instance.  Should always return an array.
   def search(key, *args)
     request = request(:search, key, *args)
     terminus = prepare(request)
 
     if result = terminus.search(request)
       raise Puppet::DevError, "Search results from terminus #{terminus.name} are not an array" unless result.is_a?(Array)
       result.each do |instance|
         next unless instance.respond_to? :expiration
         instance.expiration ||= self.expiration
       end
       return result
     end
   end
 
   # Save the instance in the appropriate terminus.  This method is
   # normally an instance method on the indirected class.
   def save(instance, key = nil)
     request = request(:save, key, instance)
     terminus = prepare(request)
 
     result = terminus.save(request)
 
     # If caching is enabled, save our document there
     cache.save(request) if cache?
 
     result
   end
 
   private
 
   # Check authorization if there's a hook available; fail if there is one
   # and it returns false.
   def check_authorization(request, terminus)
     # At this point, we're assuming authorization makes no sense without
     # client information.
     return unless request.node
 
     # This is only to authorize via a terminus-specific authorization hook.
     return unless terminus.respond_to?(:authorized?)
 
     unless terminus.authorized?(request)
       msg = "Not authorized to call #{request.method} on #{request}"
       msg += " with #{request.options.inspect}" unless request.options.empty?
       raise ArgumentError, msg
     end
   end
 
   # Setup a request, pick the appropriate terminus, check the request's authorization, and return it.
   def prepare(request)
     # Pick our terminus.
     if respond_to?(:select_terminus)
       unless terminus_name = select_terminus(request)
         raise ArgumentError, "Could not determine appropriate terminus for #{request}"
       end
     else
       terminus_name = terminus_class
     end
 
     dest_terminus = terminus(terminus_name)
     check_authorization(request, dest_terminus)
 
     dest_terminus
   end
 
   # Create a new terminus instance.
   def make_terminus(terminus_class)
     # Load our terminus class.
     unless klass = Puppet::Indirector::Terminus.terminus_class(self.name, terminus_class)
       raise ArgumentError, "Could not find terminus #{terminus_class} for indirection #{self.name}"
     end
     klass.new
   end
 end
diff --git a/lib/puppet/indirector/ldap.rb b/lib/puppet/indirector/ldap.rb
index 8d7cd076a..696cb4091 100644
--- a/lib/puppet/indirector/ldap.rb
+++ b/lib/puppet/indirector/ldap.rb
@@ -1,78 +1,79 @@
 require 'puppet/indirector/terminus'
 require 'puppet/util/ldap/connection'
 
 class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
   # Perform our ldap search and process the result.
   def find(request)
     ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
   end
 
   # Process the found entry.  We assume that we don't just want the
   # ldap object.
   def process(entry)
     raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for #{self.name}"
   end
 
   # Default to all attributes.
   def search_attributes
     nil
   end
 
   def search_base
     Puppet[:ldapbase]
   end
 
   # The ldap search filter to use.
   def search_filter(name)
     raise Puppet::DevError, "No search string set for LDAP terminus for #{self.name}"
   end
 
   # Find the ldap node, return the class list and parent node specially,
   # and everything else in a parameter hash.
   def ldapsearch(filter)
     raise ArgumentError.new("You must pass a block to ldapsearch") unless block_given?
 
     found = false
     count = 0
 
     begin
       connection.search(search_base, 2, filter, search_attributes) do |entry|
         found = true
         yield entry
       end
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
       if count == 0
         # Try reconnecting to ldap if we get an exception and we haven't yet retried.
         count += 1
         @connection = nil
         Puppet.warning "Retrying LDAP connection"
         retry
       else
         error = Puppet::Error.new("LDAP Search failed")
         error.set_backtrace(detail.backtrace)
         raise error
       end
     end
 
     found
   end
 
   # Create an ldap connection.
   def connection
     unless @connection
       raise Puppet::Error, "Could not set up LDAP Connection: Missing ruby/ldap libraries" unless Puppet.features.ldap?
       begin
         conn = Puppet::Util::Ldap::Connection.instance
         conn.start
         @connection = conn.connection
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        raise Puppet::Error, "Could not connect to LDAP: #{detail}"
+        message = "Could not connect to LDAP: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message
       end
     end
 
     @connection
   end
 end
diff --git a/lib/puppet/indirector/queue.rb b/lib/puppet/indirector/queue.rb
index 85ffacacc..299032bcb 100644
--- a/lib/puppet/indirector/queue.rb
+++ b/lib/puppet/indirector/queue.rb
@@ -1,81 +1,80 @@
 require 'puppet/indirector/terminus'
 require 'puppet/util/queue'
 require 'puppet/util'
 
 # Implements the <tt>:queue</tt> abstract indirector terminus type, for storing
 # model instances to a message queue, presumably for the purpose of out-of-process
 # handling of changes related to the model.
 #
 # Relies upon Puppet::Util::Queue for registry and client object management,
 # and specifies a default queue type of <tt>:stomp</tt>, appropriate for use with a variety of message brokers.
 #
 # It's up to the queue client type to instantiate itself correctly based on Puppet configuration information.
 #
 # A single queue client is maintained for the abstract terminus, meaning that you can only use one type
 # of queue client, one message broker solution, etc., with the indirection mechanism.
 #
 # Per-indirection queues are assumed, based on the indirection name.  If the <tt>:catalog</tt> indirection makes
 # use of this <tt>:queue</tt> terminus, queue operations work against the "catalog" queue.  It is up to the queue
 # client library to handle queue creation as necessary (for a number of popular queuing solutions, queue
 # creation is automatic and not a concern).
 class Puppet::Indirector::Queue < Puppet::Indirector::Terminus
   extend ::Puppet::Util::Queue
   include Puppet::Util
 
   def initialize(*args)
     super
     raise ArgumentError, "Queueing requires pson support" unless Puppet.features.pson?
   end
 
   # Queue has no idiomatic "find"
   def find(request)
     nil
   end
 
   # Place the request on the queue
   def save(request)
       result = nil
       benchmark :info, "Queued #{indirection.name} for #{request.key}" do
         result = client.publish_message(queue, request.instance.render(:pson))
       end
       result
   rescue => detail
       raise Puppet::Error, "Could not write #{request.key} to queue: #{detail}\nInstance::#{request.instance}\n client : #{client}"
   end
 
   def self.queue
     indirection_name
   end
 
   def queue
     self.class.queue
   end
 
   # Returns the singleton queue client object.
   def client
     self.class.client
   end
 
   # converts the _message_ from deserialized format to an actual model instance.
   def self.intern(message)
     result = nil
     benchmark :info, "Loaded queued #{indirection.name}" do
       result = model.convert_from(:pson, message)
     end
     result
   end
 
   # Provides queue subscription functionality; for a given indirection, use this method on the terminus
   # to subscribe to the indirection-specific queue.  Your _block_ will be executed per new indirection
   # model received from the queue, with _obj_ being the model instance.
   def self.subscribe
     client.subscribe(queue) do |msg|
       begin
         yield(self.intern(msg))
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}"
+        Puppet.log_exception(detail, "Error occured with subscription to queue #{queue} for indirection #{indirection_name}: #{detail}")
       end
     end
   end
 end
diff --git a/lib/puppet/indirector/report/processor.rb b/lib/puppet/indirector/report/processor.rb
index dfda0f6ce..b60046de8 100644
--- a/lib/puppet/indirector/report/processor.rb
+++ b/lib/puppet/indirector/report/processor.rb
@@ -1,61 +1,60 @@
 require 'puppet/transaction/report'
 require 'puppet/indirector/code'
 require 'puppet/reports'
 
 class Puppet::Transaction::Report::Processor < Puppet::Indirector::Code
   desc "Puppet's report processor.  Processes the report with each of
     the report types listed in the 'reports' setting."
 
   def initialize
     Puppet.settings.use(:main, :reporting, :metrics)
   end
 
   def save(request)
     process(request.instance)
   end
 
   def destroy(request)
     processors do |mod|
       mod.destroy(request.key) if mod.respond_to?(:destroy)
     end
   end
 
   private
 
   # Process the report with each of the configured report types.
   # LAK:NOTE This isn't necessarily the best design, but it's backward
   # compatible and that's good enough for now.
   def process(report)
     Puppet.debug "Received report to process from #{report.host}"
     processors do |mod|
       Puppet.debug "Processing report from #{report.host} with processor #{mod}"
       # We have to use a dup because we're including a module in the
       # report.
       newrep = report.dup
       begin
         newrep.extend(mod)
         newrep.process
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Report #{name} failed: #{detail}"
+        Puppet.log_exception(detail, "Report #{name} failed: #{detail}")
       end
     end
   end
 
   # Handle the parsing of the reports attribute.
   def reports
     # LAK:NOTE See http://snurl.com/21zf8  [groups_google_com]
     x = Puppet[:reports].gsub(/(^\s+)|(\s+$)/, '').split(/\s*,\s*/)
   end
 
   def processors(&blk)
     return if Puppet[:reports] == "none"
     reports.each do |name|
       if mod = Puppet::Reports.report(name)
         yield(mod)
       else
         Puppet.warning "No report named '#{name}'"
       end
     end
   end
 end
diff --git a/lib/puppet/network/http/handler.rb b/lib/puppet/network/http/handler.rb
index 2c78a0283..c25798d5a 100644
--- a/lib/puppet/network/http/handler.rb
+++ b/lib/puppet/network/http/handler.rb
@@ -1,244 +1,243 @@
 module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http/api/v1'
 require 'puppet/network/rest_authorization'
 require 'puppet/network/rights'
 require 'resolv'
 
 module Puppet::Network::HTTP::Handler
   include Puppet::Network::HTTP::API::V1
   include Puppet::Network::RestAuthorization
 
   attr_reader :server, :handler
 
   # Retrieve the accept header from the http request.
   def accept_header(request)
     raise NotImplementedError
   end
 
   # Retrieve the Content-Type header from the http request.
   def content_type_header(request)
     raise NotImplementedError
   end
 
   # Which format to use when serializing our response or interpreting the request.
   # IF the client provided a Content-Type use this, otherwise use the Accept header
   # and just pick the first value.
   def format_to_use(request)
     unless header = accept_header(request)
       raise ArgumentError, "An Accept header must be provided to pick the right format"
     end
 
     format = nil
     header.split(/,\s*/).each do |name|
       next unless format = Puppet::Network::FormatHandler.format(name)
       next unless format.suitable?
       return format
     end
 
     raise "No specified acceptable formats (#{header}) are functional on this machine"
   end
 
   def request_format(request)
     if header = content_type_header(request)
       header.gsub!(/\s*;.*$/,'') # strip any charset
       format = Puppet::Network::FormatHandler.mime(header)
       raise "Client sent a mime-type (#{header}) that doesn't correspond to a format we support" if format.nil?
       return format.name.to_s if format.suitable?
     end
 
     raise "No Content-Type header was received, it isn't possible to unserialize the request"
   end
 
   def format_to_mime(format)
     format.is_a?(Puppet::Network::Format) ? format.mime : format
   end
 
   def initialize_for_puppet(server)
     @server = server
   end
 
   # handle an HTTP request
   def process(request, response)
     indirection, method, key, params = uri2indirection(http_method(request), path(request), params(request))
 
     check_authorization(indirection, method, key, params)
 
     send("do_#{method}", indirection, key, params, request, response)
   rescue SystemExit,NoMemoryError
     raise
   rescue Exception => e
     return do_exception(response, e)
   end
 
   # Set the response up, with the body and status.
   def set_response(response, body, status = 200)
     raise NotImplementedError
   end
 
   # Set the specified format as the content type of the response.
   def set_content_type(response, format)
     raise NotImplementedError
   end
 
   def do_exception(response, exception, status=400)
     if exception.is_a?(Puppet::Network::AuthorizationError)
       # make sure we return the correct status code
       # for authorization issues
       status = 403 if status == 400
     end
     if exception.is_a?(Exception)
-      puts exception.backtrace if Puppet[:trace]
-      Puppet.err(exception)
+      Puppet.log_exception(exception)
     end
     set_content_type(response, "text/plain")
     set_response(response, exception.to_s, status)
   end
 
   def model(indirection_name)
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless indirection = Puppet::Indirector::Indirection.instance(indirection_name.to_sym)
     indirection.model
   end
 
   # Execute our find.
   def do_find(indirection_name, key, params, request, response)
     unless result = model(indirection_name).indirection.find(key, params)
       Puppet.info("Could not find #{indirection_name} for '#{key}'")
       return do_exception(response, "Could not find #{indirection_name} #{key}", 404)
     end
 
     # The encoding of the result must include the format to use,
     # and it needs to be used for both the rendering and as
     # the content type.
     format = format_to_use(request)
     set_content_type(response, format)
 
     if result.respond_to?(:render)
       set_response(response, result.render(format))
     else
       set_response(response, result)
     end
   end
 
   # Execute our head.
   def do_head(indirection_name, key, params, request, response)
     unless self.model(indirection_name).indirection.head(key, params)
       Puppet.info("Could not find #{indirection_name} for '#{key}'")
       return do_exception(response, "Could not find #{indirection_name} #{key}", 404)
     end
 
     # No need to set a response because no response is expected from a
     # HEAD request.  All we need to do is not die.
   end
 
   # Execute our search.
   def do_search(indirection_name, key, params, request, response)
     model  = self.model(indirection_name)
     result = model.indirection.search(key, params)
 
     if result.nil?
       return do_exception(response, "Could not find instances in #{indirection_name} with '#{key}'", 404)
     end
 
     format = format_to_use(request)
     set_content_type(response, format)
 
     set_response(response, model.render_multiple(format, result))
   end
 
   # Execute our destroy.
   def do_destroy(indirection_name, key, params, request, response)
     result = model(indirection_name).indirection.destroy(key, params)
 
     return_yaml_response(response, result)
   end
 
   # Execute our save.
   def do_save(indirection_name, key, params, request, response)
     data = body(request).to_s
     raise ArgumentError, "No data to save" if !data or data.empty?
 
     format = request_format(request)
     obj = model(indirection_name).convert_from(format, data)
     result = model(indirection_name).indirection.save(obj, key)
     return_yaml_response(response, result)
   end
 
   # resolve node name from peer's ip address
   # this is used when the request is unauthenticated
   def resolve_node(result)
     begin
       return Resolv.getname(result[:ip])
     rescue => detail
       Puppet.err "Could not resolve #{result[:ip]}: #{detail}"
     end
     result[:ip]
   end
 
   private
 
   def return_yaml_response(response, body)
     set_content_type(response, Puppet::Network::FormatHandler.format("yaml"))
     set_response(response, body.to_yaml)
   end
 
   def get?(request)
     http_method(request) == 'GET'
   end
 
   def put?(request)
     http_method(request) == 'PUT'
   end
 
   def delete?(request)
     http_method(request) == 'DELETE'
   end
 
   # methods to be overridden by the including web server class
 
   def http_method(request)
     raise NotImplementedError
   end
 
   def path(request)
     raise NotImplementedError
   end
 
   def request_key(request)
     raise NotImplementedError
   end
 
   def body(request)
     raise NotImplementedError
   end
 
   def params(request)
     raise NotImplementedError
   end
 
   def decode_params(params)
     params.inject({}) do |result, ary|
       param, value = ary
       next result if param.nil? || param.empty?
 
       param = param.to_sym
 
       # These shouldn't be allowed to be set by clients
       # in the query string, for security reasons.
       next result if param == :node
       next result if param == :ip
       value = CGI.unescape(value)
       if value =~ /^---/
         value = YAML.load(value)
       else
         value = true if value == "true"
         value = false if value == "false"
         value = Integer(value) if value =~ /^\d+$/
         value = value.to_f if value =~ /^\d+\.\d+$/
       end
       result[param] = value
       result
     end
   end
 end
diff --git a/lib/puppet/network/http/rack.rb b/lib/puppet/network/http/rack.rb
index 63b611982..908b2004c 100644
--- a/lib/puppet/network/http/rack.rb
+++ b/lib/puppet/network/http/rack.rb
@@ -1,35 +1,33 @@
 require 'rack'
 require 'rack/request'
 require 'rack/response'
 
 require 'puppet/network/http'
 require 'puppet/network/http/rack/rest'
 
 # An rack application, for running the Puppet HTTP Server.
 class Puppet::Network::HTTP::Rack
   # The real rack application (which needs to respond to call).
   # The work we need to do, roughly is:
   # * Read request (from env) and prepare a response
   # * Route the request to the correct handler
   # * Return the response (in rack-format) to our caller.
   def call(env)
     request = Rack::Request.new(env)
     response = Rack::Response.new
     Puppet.debug 'Handling request: %s %s' % [request.request_method, request.fullpath]
 
     begin
       Puppet::Network::HTTP::RackREST.new.process(request, response)
     rescue => detail
       # Send a Status 500 Error on unhandled exceptions.
       response.status = 500
       response['Content-Type'] = 'text/plain'
       response.write 'Internal Server Error: "%s"' % detail.message
       # log what happened
-      Puppet.err "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message
-      Puppet.err "Backtrace:"
-      detail.backtrace.each { |line| Puppet.err " > #{line}" }
+      Puppet.log_exception(detail, "Puppet Server (Rack): Internal Server Error: Unhandled Exception: \"%s\"" % detail.message)
     end
     response.finish
   end
 end
 
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 90732b564..9b3b5d45e 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,486 +1,487 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     # We get these from the environment and only cache them in a thread
     # variable for the duration of the compilation.  If nothing else is using
     # the thread, though, we can leave 'em hanging round with no ill effects,
     # and this is safer than cleaning them at the end and assuming that will
     # stick until the next entry to this function.
     Thread.current[:known_resource_types] = nil
     Thread.current[:env_module_directories] = nil
 
     # ...and we actually do the compile now we have caching ready.
     new(node).compile.to_resource
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    raise Puppet::Error, "#{detail} on node #{node.name}"
+    message = "#{detail} on node #{node.name}"
+    Puppet.log_exception(detail, message)
+    raise Puppet::Error, message
  end
 
   attr_reader :node, :facts, :collections, :catalog, :node_scope, :resources, :relationships
 
   # Add a collection to the global list.
   def add_collection(coll)
     @collections << coll
   end
 
   def add_relationship(dep)
     @relationships << dep
   end
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   # Store a resource in our resource table.
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if resource.type.to_s.downcase != "class" && resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.type.to_s.downcase == "stage"
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     if resource.type.to_s.downcase != "class"
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def ast_nodes?
     known_resource_types.nodes?
   end
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def classlist
     @catalog.classes
   end
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     # Set the client's parameters into the top scope.
     set_node_parameters
     create_settings_scope
 
     evaluate_main
 
     evaluate_ast_node
 
     evaluate_node_classes
 
     evaluate_generators
 
     finish
 
     fail_on_unevaluated
 
     @catalog
   end
 
   # LAK:FIXME There are no tests for this.
   def delete_collection(coll)
     @collections.delete(coll) if @collections.include?(coll)
   end
 
   # Return the node's environment.
   def environment
     unless defined?(@environment)
       @environment = (node.environment and node.environment != "") ? node.environment : nil
     end
     Puppet::Node::Environment.current = @environment
     @environment
   end
 
   # Evaluate all of the classes specified by the node.
   def evaluate_node_classes
     evaluate_classes(@node.classes, topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   def evaluate_classes(classes, scope, lazy_evaluate = true)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
     classes.each do |name|
       # If we can find the class, then make a resource that will evaluate it.
       if klass = scope.find_hostclass(name)
 
         # If parameters are passed, then attempt to create a duplicate resource
         # so the appropriate error is thrown.
         if class_parameters
           resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
         else
           next if scope.class_scope(klass)
           resource = klass.ensure_in_catalog(scope)
         end
 
         # If they've disabled lazy evaluation (which the :include function does),
         # then evaluate our resource immediately.
         resource.evaluate unless lazy_evaluate
       else
         raise Puppet::Error, "Could not find class #{name} for #{node.name}"
       end
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def findresource(*args)
     @catalog.resource(*args)
   end
 
   def initialize(node, options = {})
     @node = node
 
     options.each do |param, value|
       begin
         send(param.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "Compiler objects do not accept #{param}"
       end
     end
 
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     options[:compiler] = self
     scope = Puppet::Parser::Scope.new(options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   # The top scope is usually the top-level scope, but if we're using AST nodes,
   # then it is instead the node's scope.
   def topscope
     node_scope || @topscope
   end
 
   private
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     # Now set the node scope appropriately, so that :topscope can
     # behave differently.
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     found_something = false
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       @collections.dup.each do |collection|
         found_something = true if collection.evaluate
       end
     end
 
     found_something
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       !unevaluated_resources.each { |resource| resource.evaluate }.empty?
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       # Call collections first, then definitions.
       done = false if evaluate_collections
       done = false if evaluate_definitions
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = []
     @resource_overrides.each do |name, overrides|
       remaining.concat overrides
     end
 
     unless remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) %s for overriding" % remaining.collect { |o|
           o.ref
         }.join(", ")
     end
   end
 
   # Make sure we don't have any remaining collections that specifically
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
     remaining = []
     @collections.each do |coll|
       # We're only interested in the 'resource' collections,
       # which result from direct calls of 'realize'.  Anything
       # else is allowed not to return resources.
       # Collect all of them, so we have a useful error.
       if r = coll.resources
         if r.is_a?(Array)
           remaining += r
         else
           remaining << r
         end
       end
     end
 
     raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = []
     Puppet::Type.eachmetaparam do |name|
       next if Puppet::Parser::Resource.relationship_parameter?(name)
       names << name
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of objects that will available for export.
     @exported_resources = {}
 
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name)
     @catalog.version = known_resource_types.version
 
     # Create our initial scope and a resource that will evaluate main.
     @topscope = Puppet::Parser::Scope.new(:compiler => self)
 
     @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
     @catalog.add_resource(@main_stage_resource)
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope[param] = value
     end
 
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
   end
 
   def create_settings_scope
     unless settings_type = environment.known_resource_types.hostclass("settings")
       settings_type = Puppet::Resource::Type.new :hostclass, "settings"
       environment.known_resource_types.add(settings_type)
     end
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
 
     settings_type.evaluate_code(settings_resource)
 
     scope = @topscope.class_scope(settings_type)
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
       scope[name.to_s] = environment[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 0d19586a8..2edbcd829 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -1,335 +1,335 @@
 require 'puppet/resource'
 
 # The primary difference between this class and its
 # parent is that this class has rules on who can set
 # parameters
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
   require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
   include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
   include Puppet::Util::Tagging
   include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
 
   attr_reader :exported, :parameters
 
   # Determine whether the provided parameter name is a relationship parameter.
   def self.relationship_parameter?(name)
     @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
     @relationship_names.include?(name)
   end
 
   # Set up some boolean test methods
   def translated?; !!@translated; end
   def override?;   !!@override;   end
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
     param = symbolize(param)
     if param == :title
       return self.title
     end
     if @parameters.has_key?(param)
       @parameters[param].value
     else
       nil
     end
   end
 
   def []=(param, value)
     set_parameter(param, value)
   end
 
   def eachparam
     @parameters.each do |name, param|
       yield param
     end
   end
 
   def environment
     scope.environment
   end
 
   # Process the  stage metaparameter for a class.   A containment edge
   # is drawn from  the class to the stage.   The stage for containment
   # defaults to main, if none is specified.
   def add_edge_to_stage
     return unless self.type.to_s.downcase == "class"
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
       raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
     catalog.add_edge(stage, self)
   end
 
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
       evaluated_code = klass.evaluate_code(self)
 
       return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else
       self.fail "Cannot find definition #{type}"
     end
   end
 
   # Mark this resource as both exported and virtual,
   # or remove the exported mark.
   def exported=(value)
     if value
       @virtual = true
       @exported = value
     else
       @exported = value
     end
   end
 
   # Do any finishing work on this object, called before evaluation or
   # before storage/translation.
   def finish
     return if finished?
     @finished = true
     add_defaults
     add_metaparams
     add_scope_tags
     validate
   end
 
   # Has this resource already been finished?
   def finished?
     @finished
   end
 
   def initialize(*args)
     raise ArgumentError, "Resources require a scope" unless args.last[:scope]
     super
 
     @source ||= scope.source
   end
 
   # Is this resource modeling an isomorphic resource type?
   def isomorphic?
     if builtin_type?
       return resource_type.isomorphic?
     else
       return true
     end
   end
 
   # Merge an override resource in.  This will throw exceptions if
   # any overrides aren't allowed.
   def merge(resource)
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
       raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
       override_parameter(param)
     end
   end
 
   # Unless we're running >= 0.25, we're in compat mode.
   def metaparam_compatibility_mode?
     ! (catalog and ver = (catalog.client_version||'0.0.0').split(".") and (ver[0] > "0" or ver[1].to_i >= 25))
   end
 
   def name
     self[:name] || self.title
   end
 
   # A temporary occasion, until I get paths in the scopes figured out.
   def path
     to_s
   end
 
   # Define a parameter in our resource.
   # if we ever receive a parameter named 'tag', set
   # the resource tags with its value.
   def set_parameter(param, value = nil)
     if ! value.nil?
       param = Puppet::Parser::Resource::Param.new(
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
       raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
     end
 
     tag(*param.value) if param.name == :tag
 
     # And store it in our parameter hash.
     @parameters[param.name] = param
   end
 
   def to_hash
     @parameters.inject({}) do |hash, ary|
       param = ary[1]
       # Skip "undef" values.
       hash[param.name] = param.value if param.value != :undef
       hash
     end
   end
 
 
   # Create a Puppet::Resource instance from this parser resource.
   # We plan, at some point, on not needing to do this conversion, but
   # it's sufficient for now.
   def to_resource
     result = Puppet::Resource.new(type, title)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
 
     result
   end
 
   # Convert this resource to a RAL resource.
   def to_ral
     to_resource.to_ral
   end
 
   private
 
   # Add default values from our definition.
   def add_defaults
     scope.lookupdefaults(self.type).each do |name, param|
       unless @parameters.include?(name)
         self.debug "Adding default for #{name}"
 
         @parameters[name] = param.dup
       end
     end
   end
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
     return unless scope.include?(name.to_s)
     val = scope[name.to_s]
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
 
     # For relationship params, though, join the values (a la #446).
     @parameters[name].value = [@parameters[name].value, val].flatten
   end
 
   # Add any metaparams defined in our scope. This actually adds any metaparams
   # from any parent scope, and there's currently no way to turn that off.
   def add_metaparams
     compat_mode = metaparam_compatibility_mode?
 
     Puppet::Type.eachmetaparam do |name|
       next unless self.class.relationship_parameter?(name)
       add_backward_compatible_relationship_param(name) if compat_mode
     end
   end
 
   def add_scope_tags
     if scope_resource = scope.resource
       tag(*scope_resource.tags)
     end
   end
 
   # Accept a parameter from an override.
   def override_parameter(param)
     # This can happen if the override is defining a new parameter, rather
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
     # The parameter is already set.  Fail if they're not allowed to override it.
     unless param.source.child_of?(current.source)
-      puts caller if Puppet[:trace]
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
         fields = []
         fields << current.file if current.file
         fields << current.line.to_s if current.line
         msg += " at #{fields.join(":")}"
       end
       msg += "; cannot redefine"
+      Puppet.log_exception(ArgumentError.new(), msg)
       raise Puppet::ParseError.new(msg, param.line, param.file)
     end
 
     # If we've gotten this far, we're allowed to override.
 
     # Merge with previous value, if the parameter was generated with the +>
     # syntax.  It's important that we use a copy of the new param instance
     # here, not the old one, and not the original new one, so that the source
     # is registered correctly for later overrides but the values aren't
     # implcitly shared when multiple resources are overrriden at once (see
     # ticket #3556).
     if param.add
       param = param.dup
       param.value = [current.value, param.value].flatten
     end
 
     set_parameter(param)
   end
 
   # Make sure the resource's parameters are all valid for the type.
   def validate
     @parameters.each do |name, param|
       validate_parameter(name)
     end
   rescue => detail
     fail Puppet::ParseError, detail.to_s
   end
 
   private
 
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
       self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
 
       set_parameter(param)
     end
   end
 end
diff --git a/lib/puppet/property.rb b/lib/puppet/property.rb
index 2af4d30b3..602fa0337 100644
--- a/lib/puppet/property.rb
+++ b/lib/puppet/property.rb
@@ -1,371 +1,372 @@
 # The virtual base class for properties, which are the self-contained building
 # blocks for actually doing work on the system.
 
 require 'puppet'
 require 'puppet/parameter'
 
 class Puppet::Property < Puppet::Parameter
   require 'puppet/property/ensure'
 
   # Because 'should' uses an array, we have a special method for handling
   # it.  We also want to keep copies of the original values, so that
   # they can be retrieved and compared later when merging.
   attr_reader :shouldorig
 
   attr_writer :noop
 
   class << self
     attr_accessor :unmanaged
     attr_reader :name
 
     # Return array matching info, defaulting to just matching
     # the first value.
     def array_matching
       @array_matching ||= :first
     end
 
     # Set whether properties should match all values or just the first one.
     def array_matching=(value)
       value = value.intern if value.is_a?(String)
       raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'" unless [:first, :all].include?(value)
       @array_matching = value
     end
   end
 
   # Look up a value's name, so we can find options and such.
   def self.value_name(name)
     if value = value_collection.match?(name)
       value.name
     end
   end
 
   # Retrieve an option set when a value was defined.
   def self.value_option(name, option)
     if value = value_collection.value(name)
       value.send(option)
     end
   end
 
   # Define a new valid value for a property.  You must provide the value itself,
   # usually as a symbol, or a regex to match the value.
   #
   # The first argument to the method is either the value itself or a regex.
   # The second argument is an option hash; valid options are:
   # * <tt>:method</tt>: The name of the method to define.  Defaults to 'set_<value>'.
   # * <tt>:required_features</tt>: A list of features this value requires.
   # * <tt>:event</tt>: The event that should be returned when this value is set.
   # * <tt>:call</tt>: When to call any associated block.  The default value
   #   is `instead`, which means to call the value instead of calling the
   #   provider.  You can also specify `before` or `after`, which will
   #   call both the block and the provider, according to the order you specify
   #   (the `first` refers to when the block is called, not the provider).
   def self.newvalue(name, options = {}, &block)
     value = value_collection.newvalue(name, options, &block)
 
     define_method(value.method, &value.block) if value.method and value.block
     value
   end
 
   # Call the provider method.
   def call_provider(value)
       provider.send(self.class.name.to_s + "=", value)
   rescue NoMethodError
       self.fail "The #{provider.class.name} provider can not handle attribute #{self.class.name}"
   end
 
   # Call the dynamically-created method associated with our value, if
   # there is one.
   def call_valuemethod(name, value)
     if method = self.class.value_option(name, :method) and self.respond_to?(method)
       begin
         event = self.send(method)
       rescue Puppet::Error
         raise
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
         error = Puppet::Error.new("Could not set '#{value} on #{self.class.name}: #{detail}", @resource.line, @resource.file)
         error.set_backtrace detail.backtrace
+        Puppet.log_exception(detail, error.message)
         raise error
       end
     elsif block = self.class.value_option(name, :block)
       # FIXME It'd be better here to define a method, so that
       # the blocks could return values.
       self.instance_eval(&block)
     else
       devfail "Could not find method for value '#{name}'"
     end
   end
 
   # How should a property change be printed as a string?
   def change_to_s(current_value, newvalue)
     begin
       if current_value == :absent
         return "defined '#{name}' as #{self.class.format_value_for_display should_to_s(newvalue)}"
       elsif newvalue == :absent or newvalue == [:absent]
         return "undefined '#{name}' from #{self.class.format_value_for_display is_to_s(current_value)}"
       else
         return "#{name} changed #{self.class.format_value_for_display is_to_s(current_value)} to #{self.class.format_value_for_display should_to_s(newvalue)}"
       end
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::DevError, "Could not convert change '#{name}' to string: #{detail}"
+      message = "Could not convert change '#{name}' to string: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::DevError, message
     end
   end
 
   # Figure out which event to return.
   def event_name
     value = self.should
 
     event_name = self.class.value_option(value, :event) and return event_name
 
     name == :ensure or return (name.to_s + "_changed").to_sym
 
     return (resource.type.to_s + case value
     when :present; "_created"
     when :absent; "_removed"
     else
       "_changed"
     end).to_sym
   end
 
   # Return a modified form of the resource event.
   def event
     resource.event :name => event_name, :desired_value => should, :property => self, :source_description => path
   end
 
   attr_reader :shadow
 
   # initialize our property
   def initialize(hash = {})
     super
 
     if ! self.metaparam? and klass = Puppet::Type.metaparamclass(self.class.name)
       setup_shadow(klass)
     end
   end
 
   # Determine whether the property is in-sync or not.  If @should is
   # not defined or is set to a non-true value, then we do not have
   # a valid value for it and thus consider the property to be in-sync
   # since we cannot fix it.  Otherwise, we expect our should value
   # to be an array, and if @is matches any of those values, then
   # we consider it to be in-sync.
   #
   # Don't override this method.
   def safe_insync?(is)
     # If there is no @should value, consider the property to be in sync.
     return true unless @should
 
     # Otherwise delegate to the (possibly derived) insync? method.
     insync?(is)
   end
 
   def self.method_added(sym)
     raise "Puppet::Property#safe_insync? shouldn't be overridden; please override insync? instead" if sym == :safe_insync?
   end
 
   # This method may be overridden by derived classes if necessary
   # to provide extra logic to determine whether the property is in
   # sync.  In most cases, however, only `property_matches?` needs to be
   # overridden to give the correct outcome - without reproducing all the array
   # matching logic, etc, found here.
   def insync?(is)
     self.devfail "#{self.class.name}'s should is not array" unless @should.is_a?(Array)
 
     # an empty array is analogous to no should values
     return true if @should.empty?
 
     # Look for a matching value, either for all the @should values, or any of
     # them, depending on the configuration of this property.
     if match_all? then
       # Emulate Array#== using our own comparison function.
       # A non-array was not equal to an array, which @should always is.
       return false unless is.is_a? Array
 
       # If they were different lengths, they are not equal.
       return false unless is.length == @should.length
 
       # Finally, are all the elements equal?  In order to preserve the
       # behaviour of previous 2.7.x releases, we need to impose some fun rules
       # on "equality" here.
       #
       # Specifically, we need to implement *this* comparison: the two arrays
       # are identical if the is values are == the should values, or if the is
       # values are == the should values, stringified.
       #
       # This does mean that property equality is not commutative, and will not
       # work unless the `is` value is carefully arranged to match the should.
       return (is == @should or is == @should.map(&:to_s))
 
       # When we stop being idiots about this, and actually have meaningful
       # semantics, this version is the thing we actually want to do.
       #
       # return is.zip(@should).all? {|a, b| property_matches?(a, b) }
     else
       return @should.any? {|want| property_matches?(is, want) }
     end
   end
 
   # Compare the current and desired value of a property in a property-specific
   # way.  Invoked by `insync?`; this should be overridden if your property
   # has a different comparison type but does not actually differentiate the
   # overall insync? logic.
   def property_matches?(current, desired)
     # This preserves the older Puppet behaviour of doing raw and string
     # equality comparisons for all equality.  I am not clear this is globally
     # desirable, but at least it is not a breaking change. --daniel 2011-11-11
     current == desired or current == desired.to_s
   end
 
   # because the @should and @is vars might be in weird formats,
   # we need to set up a mechanism for pretty printing of the values
   # default to just the values, but this way individual properties can
   # override these methods
   def is_to_s(currentvalue)
     currentvalue
   end
 
   # Send a log message.
   def log(msg)
     Puppet::Util::Log.create(
       :level   => resource[:loglevel],
       :message => msg,
       :source  => self
     )
   end
 
   # Should we match all values, or just the first?
   def match_all?
     self.class.array_matching == :all
   end
 
   # Execute our shadow's munge code, too, if we have one.
   def munge(value)
     self.shadow.munge(value) if self.shadow
 
     super
   end
 
   # each property class must define the name method, and property instances
   # do not change that name
   # this implicitly means that a given object can only have one property
   # instance of a given property class
   def name
     self.class.name
   end
 
   # for testing whether we should actually do anything
   def noop
     # This is only here to make testing easier.
     if @resource.respond_to?(:noop?)
       @resource.noop?
     else
       if defined?(@noop)
         @noop
       else
         Puppet[:noop]
       end
     end
   end
 
   # By default, call the method associated with the property name on our
   # provider.  In other words, if the property name is 'gid', we'll call
   # 'provider.gid' to retrieve the current value.
   def retrieve
     provider.send(self.class.name)
   end
 
   # Set our value, using the provider, an associated block, or both.
   def set(value)
     # Set a name for looking up associated options like the event.
     name = self.class.value_name(value)
 
     call = self.class.value_option(name, :call) || :none
 
     if call == :instead
       call_valuemethod(name, value)
     elsif call == :none
       # They haven't provided a block, and our parent does not have
       # a provider, so we have no idea how to handle this.
       self.fail "#{self.class.name} cannot handle values of type #{value.inspect}" unless @resource.provider
       call_provider(value)
     else
       # LAK:NOTE 20081031 This is a change in behaviour -- you could
       # previously specify :call => [;before|:after], which would call
       # the setter *in addition to* the block.  I'm convinced this
       # was never used, and it makes things unecessarily complicated.
       # If you want to specify a block and still call the setter, then
       # do so in the block.
       devfail "Cannot use obsolete :call value '#{call}' for property '#{self.class.name}'"
     end
   end
 
   # If there's a shadowing metaparam, instantiate it now.
   # This allows us to create a property or parameter with the
   # same name as a metaparameter, and the metaparam will only be
   # stored as a shadow.
   def setup_shadow(klass)
     @shadow = klass.new(:resource => self.resource)
   end
 
   # Only return the first value
   def should
     return nil unless defined?(@should)
 
     self.devfail "should for #{self.class.name} on #{resource.name} is not an array" unless @should.is_a?(Array)
 
     if match_all?
       return @should.collect { |val| self.unmunge(val) }
     else
       return self.unmunge(@should[0])
     end
   end
 
   # Set the should value.
   def should=(values)
     values = [values] unless values.is_a?(Array)
 
     @shouldorig = values
 
     values.each { |val| validate(val) }
     @should = values.collect { |val| self.munge(val) }
   end
 
   def should_to_s(newvalue)
     [newvalue].flatten.join(" ")
   end
 
   def sync
     devfail "Got a nil value for should" unless should
     set(should)
   end
 
   # Verify that the passed value is valid.
   # If the developer uses a 'validate' hook, this method will get overridden.
   def unsafe_validate(value)
     super
     validate_features_per_value(value)
   end
 
   # Make sure that we've got all of the required features for a given value.
   def validate_features_per_value(value)
     if features = self.class.value_option(self.class.value_name(value), :required_features)
       features = Array(features)
       needed_features = features.collect { |f| f.to_s }.join(", ")
       raise ArgumentError, "Provider must have features '#{needed_features}' to set '#{self.class.name}' to '#{value}'" unless provider.satisfies?(features)
     end
   end
 
   # Just return any should value we might have.
   def value
     self.should
   end
 
   # Match the Parameter interface, but we really just use 'should' internally.
   # Note that the should= method does all of the validation and such.
   def value=(value)
     self.should = value
   end
 end
diff --git a/lib/puppet/provider/package/sun.rb b/lib/puppet/provider/package/sun.rb
index 49aa81e6a..28688295e 100755
--- a/lib/puppet/provider/package/sun.rb
+++ b/lib/puppet/provider/package/sun.rb
@@ -1,154 +1,155 @@
 # Sun packaging.
 
 require 'puppet/provider/package'
 
 Puppet::Type.type(:package).provide :sun, :parent => Puppet::Provider::Package do
   desc "Sun's packaging system.  Requires that you specify the source for
     the packages you're managing."
   commands :pkginfo => "/usr/bin/pkginfo",
     :pkgadd => "/usr/sbin/pkgadd",
     :pkgrm => "/usr/sbin/pkgrm"
 
   confine :operatingsystem => :solaris
 
   defaultfor :operatingsystem => :solaris
 
   def self.instances
     packages = []
     hash = {}
     names = {
       "PKGINST" => :name,
       "NAME" => nil,
       "CATEGORY" => :category,
       "ARCH" => :platform,
       "VERSION" => :ensure,
       "BASEDIR" => :root,
       "HOTLINE" => nil,
       "EMAIL" => nil,
       "VENDOR" => :vendor,
       "DESC" => :description,
       "PSTAMP" => nil,
       "INSTDATE" => nil,
       "STATUS" => nil,
       "FILES" => nil
     }
 
     cmd = "#{command(:pkginfo)} -l"
 
     # list out all of the packages
     execpipe(cmd) { |process|
       # we're using the long listing, so each line is a separate
       # piece of information
       process.each_line { |line|
         case line
         when /^$/
           hash[:provider] = :sun
 
           packages << new(hash)
           hash = {}
         when /\s*(\w+):\s+(.+)/
           name = $1
           value = $2
           if names.include?(name)
             hash[names[name]] = value unless names[name].nil?
           end
         when /\s+\d+.+/
           # nothing; we're ignoring the FILES info
         end
       }
     }
     packages
   end
 
   # Get info on a package, optionally specifying a device.
   def info2hash(device = nil)
     names = {
       "PKGINST" => :name,
       "NAME" => nil,
       "CATEGORY" => :category,
       "ARCH" => :platform,
       "VERSION" => :ensure,
       "BASEDIR" => :root,
       "HOTLINE" => nil,
       "EMAIL" => nil,
       "VSTOCK" => nil,
       "VENDOR" => :vendor,
       "DESC" => :description,
       "PSTAMP" => nil,
       "INSTDATE" => nil,
       "STATUS" => nil,
       "FILES" => nil
     }
 
     hash = {}
     cmd = "#{command(:pkginfo)} -l"
     cmd += " -d #{device}" if device
     cmd += " #{@resource[:name]}"
 
     begin
       # list out all of the packages
       execpipe(cmd) { |process|
         # we're using the long listing, so each line is a separate
         # piece of information
         process.readlines.each { |line|
           case line
           when /^$/  # ignore
           when /\s*([A-Z]+):\s+(.+)/
             name = $1
             value = $2
             if names.include?(name)
               hash[names[name]] = value unless names[name].nil?
             end
           when /\s+\d+.+/
             # nothing; we're ignoring the FILES info
           end
         }
       }
       return hash
     rescue Puppet::ExecutionFailure => detail
       return {:ensure => :absent} if detail.message =~ /information for "#{Regexp.escape(@resource[:name])}" was not found/
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{detail}"
+      message = "Unable to get information about package #{@resource[:name]} because of: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
   end
 
   def install
     raise Puppet::Error, "Sun packages must specify a package source" unless @resource[:source]
     cmd = []
 
     cmd << "-a" << @resource[:adminfile] if @resource[:adminfile]
 
     cmd << "-r" << @resource[:responsefile] if @resource[:responsefile]
 
     cmd << "-d" << @resource[:source]
     cmd << "-n" << @resource[:name]
 
     pkgadd cmd
   end
 
   # Retrieve the version from the current package file.
   def latest
     hash = info2hash(@resource[:source])
     hash[:ensure]
   end
 
   def query
     info2hash()
   end
 
   def uninstall
     command  = ["-n"]
 
     command << "-a" << @resource[:adminfile] if @resource[:adminfile]
 
     command << @resource[:name]
     pkgrm command
   end
 
   # Remove the old package, and install the new one.  This will probably
   # often fail.
   def update
     self.uninstall if (@property_hash[:ensure] || info2hash()[:ensure]) != :absent
     self.install
   end
 end
diff --git a/lib/puppet/rails.rb b/lib/puppet/rails.rb
index c52b6871b..36b4043ea 100644
--- a/lib/puppet/rails.rb
+++ b/lib/puppet/rails.rb
@@ -1,132 +1,134 @@
 # Load the appropriate libraries, or set a class indicating they aren't available
 
 require 'facter'
 require 'puppet'
 require 'logger'
 
 module Puppet::Rails
   TIME_DEBUG = true
 
   def self.connect
     # This global init does not work for testing, because we remove
     # the state dir on every test.
     return if ActiveRecord::Base.connected?
 
     Puppet.settings.use(:main, :rails, :master)
 
     ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
     begin
       loglevel = Logger.const_get(Puppet[:rails_loglevel].upcase)
       ActiveRecord::Base.logger.level = loglevel
     rescue => detail
       Puppet.warning "'#{Puppet[:rails_loglevel]}' is not a valid Rails log level; using debug"
       ActiveRecord::Base.logger.level = Logger::DEBUG
     end
 
     # As of ActiveRecord 2.2 allow_concurrency has been deprecated and no longer has any effect.
     ActiveRecord::Base.allow_concurrency = true if Puppet::Util.activerecord_version < 2.2
 
     ActiveRecord::Base.verify_active_connections!
 
     begin
       args = database_arguments
       Puppet.info "Connecting to #{args[:adapter]} database: #{args[:database]}"
       ActiveRecord::Base.establish_connection(args)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Could not connect to database: #{detail}"
+      message = "Could not connect to database: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
   end
 
   # The arguments for initializing the database connection.
   def self.database_arguments
     adapter = Puppet[:dbadapter]
 
     args = {:adapter => adapter, :log_level => Puppet[:rails_loglevel]}
 
     case adapter
     when "sqlite3"
       args[:database] = Puppet[:dblocation]
     when "mysql", "mysql2", "postgresql"
       args[:host]     = Puppet[:dbserver] unless Puppet[:dbserver].to_s.empty?
       args[:port]     = Puppet[:dbport] unless Puppet[:dbport].to_s.empty?
       args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
       args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
       args[:pool]     = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
       args[:database] = Puppet[:dbname]
       args[:reconnect]= true
 
       socket          = Puppet[:dbsocket]
       args[:socket]   = socket unless socket.to_s.empty?
     when "oracle_enhanced"
       args[:database] = Puppet[:dbname] unless Puppet[:dbname].to_s.empty?
       args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
       args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
       args[:pool]     = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
     else
       raise ArgumentError, "Invalid db adapter #{adapter}"
     end
     args
   end
 
   # Set up our database connection.  It'd be nice to have a "use" system
   # that could make callbacks.
   def self.init
     raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
 
     connect
 
     unless ActiveRecord::Base.connection.tables.include?("resources")
       require 'puppet/rails/database/schema'
       Puppet::Rails::Schema.init
     end
 
     migrate if Puppet[:dbmigrate]
   end
 
   # Migrate to the latest db schema.
   def self.migrate
     dbdir = nil
     $LOAD_PATH.each { |d|
       tmp = File.join(d, "puppet/rails/database")
       if FileTest.directory?(tmp)
         dbdir = tmp
         break
       end
     }
 
     raise Puppet::Error, "Could not find Puppet::Rails database dir" unless dbdir
 
     raise Puppet::Error, "Database has problems, can't migrate." unless ActiveRecord::Base.connection.tables.include?("resources")
 
     Puppet.notice "Migrating"
 
     begin
       ActiveRecord::Migrator.migrate(dbdir)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
+      message = "Could not migrate database: #{detail}"
+      Puppet.log_exception(detail, message)
       raise Puppet::Error, "Could not migrate database: #{detail}"
     end
   end
 
   # Tear down the database.  Mostly only used during testing.
   def self.teardown
     raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
 
     Puppet.settings.use(:master, :rails)
 
     begin
       ActiveRecord::Base.establish_connection(database_arguments)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
+      Puppet.log_exception(detail)
       raise Puppet::Error, "Could not connect to database: #{detail}"
     end
 
     ActiveRecord::Base.connection.tables.each do |t|
       ActiveRecord::Base.connection.drop_table t
     end
   end
 end
 
 require 'puppet/rails/host' if Puppet.features.rails?
 
diff --git a/lib/puppet/reference/configuration.rb b/lib/puppet/reference/configuration.rb
index c1e225367..19e09dee2 100644
--- a/lib/puppet/reference/configuration.rb
+++ b/lib/puppet/reference/configuration.rb
@@ -1,69 +1,68 @@
 config = Puppet::Util::Reference.newreference(:configuration, :depth => 1, :doc => "A reference for all configuration parameters") do
   docs = {}
   Puppet.settings.each do |name, object|
     docs[name] = object
   end
 
   str = ""
   docs.sort { |a, b|
     a[0].to_s <=> b[0].to_s
   }.each do |name, object|
     # Make each name an anchor
     header = name.to_s
     str << markdown_header(header, 3)
 
     # Print the doc string itself
     begin
       str << object.desc.gsub(/\n/, " ")
     rescue => detail
-      puts detail.backtrace
-      puts detail
+      Puppet.log_exception(detail)
     end
     str << "\n\n"
 
     # Now print the data about the item.
     str << ""
     val = object.default
     if name.to_s == "vardir"
       val = "/var/lib/puppet"
     elsif name.to_s == "confdir"
       val = "/etc/puppet"
     end
 
     # Leave out the section information; it was apparently confusing people.
     #str << "- **Section**: #{object.section}\n"
     unless val == ""
       str << "- *Default*: #{val}\n"
     end
     str << "\n"
   end
 
   return str
 end
 
 config.header = <<EOT
 ## Configuration Settings
 
 * Each of these settings can be specified in `puppet.conf` or on the
   command line.
 * When using boolean settings on the command line, use `--setting` and
   `--no-setting` instead of `--setting (true|false)`.
 * Settings can be interpolated as `$variables` in other settings; `$environment`
   is special, in that puppet master will interpolate each agent node's
   environment instead of its own.
 * Multiple values should be specified as comma-separated lists; multiple
   directories should be separated with the system path separator (usually
   a colon).
 * Settings that take a single file or directory can optionally set the owner,
   group, and mode for their value: `rundir = $vardir/run { owner = puppet,
   group = puppet, mode = 644 }`
 * The Puppet executables will ignore any setting that isn't relevant to
   their function.
 
 See the [configuration guide][confguide] for more details.
 
 [confguide]: http://docs.puppetlabs.com/guides/configuring.html
 
 * * *
 
 EOT
diff --git a/lib/puppet/reference/metaparameter.rb b/lib/puppet/reference/metaparameter.rb
index 9235d3d26..7b04840f6 100644
--- a/lib/puppet/reference/metaparameter.rb
+++ b/lib/puppet/reference/metaparameter.rb
@@ -1,43 +1,42 @@
 metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :puppet
     next if type.name == :component
     types[type.name] = type
   }
 
   str = %{
 
 # Metaparameters
     
 Metaparameters are parameters that work with any resource type; they are part of the 
 Puppet framework itself rather than being part of the implementation of any
 given instance.  Thus, any defined metaparameter can be used with any instance
 in your manifest, including defined components.
 
 ## Available Metaparameters
 
 }
   begin
     params = []
     Puppet::Type.eachmetaparam { |param|
       params << param
     }
 
     params.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |param|
       str << markdown_header(param.to_s, 3)
       str << scrub(Puppet::Type.metaparamdoc(param))
       str << "\n\n"
     }
   rescue => detail
-    puts detail.backtrace
-    puts "incorrect metaparams: #{detail}"
+    Puppet.log_exception(detail, "incorrect metaparams: #{detail}")
     exit(1)
   end
 
   str
 end
diff --git a/lib/puppet/reports/store.rb b/lib/puppet/reports/store.rb
index cd188fafd..e811dd593 100644
--- a/lib/puppet/reports/store.rb
+++ b/lib/puppet/reports/store.rb
@@ -1,67 +1,66 @@
 require 'puppet'
 require 'fileutils'
 require 'tempfile'
 
 Puppet::Reports.register_report(:store) do
   desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
     and this just stores the file on disk, in the `reportdir` directory.
 
     These files collect quickly -- one every half hour -- so it is a good idea
     to perform some maintenance on them if you use this report (it's the only
     default report)."
 
   def process
     # We don't want any tracking back in the fs.  Unlikely, but there
     # you go.
     client = self.host.gsub("..",".")
 
     dir = File.join(Puppet[:reportdir], client)
 
     if ! FileTest.exists?(dir)
       FileUtils.mkdir_p(dir)
       FileUtils.chmod_R(0750, dir)
     end
 
     # Now store the report.
     now = Time.now.gmtime
     name = %w{year month day hour min}.collect do |method|
       # Make sure we're at least two digits everywhere
       "%02d" % now.send(method).to_s
     end.join("") + ".yaml"
 
     file = File.join(dir, name)
 
     f = Tempfile.new(name, dir)
     begin
       begin
         f.chmod(0640)
         f.print to_yaml
       ensure
         f.close
       end
       FileUtils.mv(f.path, file)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.warning "Could not write report for #{client} at #{file}: #{detail}"
+      Puppet.log_exception(detail, "Could not write report for #{client} at #{file}: #{detail}")
     end
 
     # Only testing cares about the return value
     file
   end
 
   # removes all reports for a given host
   def self.destroy(host)
     client = host.gsub("..",".")
     dir = File.join(Puppet[:reportdir], client)
 
     if File.exists?(dir)
       Dir.entries(dir).each do |file|
         next if ['.','..'].include?(file)
         file = File.join(dir, file)
         File.unlink(file) if File.file?(file)
       end
       Dir.rmdir(dir)
     end
   end
 end
 
diff --git a/lib/puppet/reports/tagmail.rb b/lib/puppet/reports/tagmail.rb
index c37341e11..7960b2ce4 100644
--- a/lib/puppet/reports/tagmail.rb
+++ b/lib/puppet/reports/tagmail.rb
@@ -1,172 +1,172 @@
 require 'puppet'
 require 'pp'
 
 require 'net/smtp'
 require 'time'
 
 Puppet::Reports.register_report(:tagmail) do
   desc "This report sends specific log messages to specific email addresses
     based on the tags in the log messages.  
 
     See the [documentation on tags](http://projects.puppetlabs.com/projects/puppet/wiki/Using_Tags) for more information.
 
     To use this report, you must create a `tagmail.conf` file in the location
     specified by the `tagmap` setting.  This is a simple file that maps tags to
     email addresses:  Any log messages in the report that match the specified
     tags will be sent to the specified email addresses.
 
     Lines in the `tagmail.conf` file consist of a comma-separated list
     of tags, a colon, and a comma-separated list of email addresses.
     Tags can be !negated with a leading exclamation mark, which will
     subtract any messages with that tag from the set of events handled
     by that line.
 
     Puppet's log levels (`debug`, `info`, `notice`, `warning`, `err`,
     `alert`, `emerg`, `crit`, and `verbose`) can also be used as tags,
     and there is an `all` tag that will always match all log messages.
 
     An example `tagmail.conf`:
 
         all: me@domain.com
         webserver, !mailserver: httpadmins@domain.com
 
     This will send all messages to `me@domain.com`, and all messages from
     webservers that are not also from mailservers to `httpadmins@domain.com`.
 
     If you are using anti-spam controls such as grey-listing on your mail
     server, you should whitelist the sending email address (controlled by
     `reportform` configuration option) to ensure your email is not discarded as spam.
     "
 
   # Find all matching messages.
   def match(taglists)
     matching_logs = []
     taglists.each do |emails, pos, neg|
       # First find all of the messages matched by our positive tags
       messages = nil
       if pos.include?("all")
         messages = self.logs
       else
         # Find all of the messages that are tagged with any of our
         # tags.
         messages = self.logs.find_all do |log|
           pos.detect { |tag| log.tagged?(tag) }
         end
       end
 
       # Now go through and remove any messages that match our negative tags
       messages = messages.reject do |log|
         true if neg.detect do |tag| log.tagged?(tag) end
       end
 
       if messages.empty?
         Puppet.info "No messages to report to #{emails.join(",")}"
         next
       else
         matching_logs << [emails, messages.collect { |m| m.to_report }.join("\n")]
       end
     end
 
     matching_logs
   end
 
   # Load the config file
   def parse(text)
     taglists = []
     text.split("\n").each do |line|
       taglist = emails = nil
       case line.chomp
       when /^\s*#/; next
       when /^\s*$/; next
       when /^\s*(.+)\s*:\s*(.+)\s*$/
         taglist = $1
         emails = $2.sub(/#.*$/,'')
       else
         raise ArgumentError, "Invalid tagmail config file"
       end
 
       pos = []
       neg = []
       taglist.sub(/\s+$/,'').split(/\s*,\s*/).each do |tag|
         unless tag =~ /^!?[-\w\.]+$/
           raise ArgumentError, "Invalid tag #{tag.inspect}"
         end
         case tag
         when /^\w+/; pos << tag
         when /^!\w+/; neg << tag.sub("!", '')
         else
           raise Puppet::Error, "Invalid tag '#{tag}'"
         end
       end
 
       # Now split the emails
       emails = emails.sub(/\s+$/,'').split(/\s*,\s*/)
       taglists << [emails, pos, neg]
     end
     taglists
   end
 
   # Process the report.  This just calls the other associated messages.
   def process
     unless FileTest.exists?(Puppet[:tagmap])
       Puppet.notice "Cannot send tagmail report; no tagmap file #{Puppet[:tagmap]}"
       return
     end
 
     taglists = parse(File.read(Puppet[:tagmap]))
 
     # Now find any appropriately tagged messages.
     reports = match(taglists)
 
     send(reports)
   end
 
   # Send the email reports.
   def send(reports)
     pid = fork do
       if Puppet[:smtpserver] != "none"
         begin
           Net::SMTP.start(Puppet[:smtpserver]) do |smtp|
             reports.each do |emails, messages|
               smtp.open_message_stream(Puppet[:reportfrom], *emails) do |p|
                 p.puts "From: #{Puppet[:reportfrom]}"
                 p.puts "Subject: Puppet Report for #{self.host}"
                 p.puts "To: " + emails.join(", ")
                 p.puts "Date: #{Time.now.rfc2822}"
                 p.puts
                 p.puts messages
               end
             end
           end
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error,
-            "Could not send report emails through smtp: #{detail}"
+          message = "Could not send report emails through smtp: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       elsif Puppet[:sendmail] != ""
         begin
           reports.each do |emails, messages|
             # We need to open a separate process for every set of email addresses
             IO.popen(Puppet[:sendmail] + " " + emails.join(" "), "w") do |p|
               p.puts "From: #{Puppet[:reportfrom]}"
               p.puts "Subject: Puppet Report for #{self.host}"
               p.puts "To: " + emails.join(", ")
 
               p.puts messages
             end
           end
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error,
-            "Could not send report emails via sendmail: #{detail}"
+          message = "Could not send report emails via sendmail: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       else
         raise Puppet::Error, "SMTP server is unset and could not find sendmail"
       end
     end
 
     # Don't bother waiting for the pid to return.
     Process.detach(pid)
   end
 end
 
diff --git a/lib/puppet/resource/catalog.rb b/lib/puppet/resource/catalog.rb
index f5b5b3c64..2c7cdd5bc 100644
--- a/lib/puppet/resource/catalog.rb
+++ b/lib/puppet/resource/catalog.rb
@@ -1,604 +1,602 @@
 require 'puppet/node'
 require 'puppet/indirector'
 require 'puppet/simple_graph'
 require 'puppet/transaction'
 
 require 'puppet/util/pson'
 
 require 'puppet/util/tagging'
 
 # This class models a node catalog.  It is the thing
 # meant to be passed from server to client, and it contains all
 # of the information in the catalog, including the resources
 # and the relationships between them.
 class Puppet::Resource::Catalog < Puppet::SimpleGraph
   class DuplicateResourceError < Puppet::Error; end
 
   extend Puppet::Indirector
   indirects :catalog, :terminus_setting => :catalog_terminus
 
   include Puppet::Util::Tagging
   extend Puppet::Util::Pson
 
   # The host name this is a catalog for.
   attr_accessor :name
 
   # The catalog version.  Used for testing whether a catalog
   # is up to date.
   attr_accessor :version
 
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
   # Whether this is a host catalog, which behaves very differently.
   # In particular, reports are sent, graphs are made, and state is
   # stored in the state database.  If this is set incorrectly, then you often
   # end up in infinite loops, because catalogs are used to make things
   # that the host catalog needs.
   attr_accessor :host_config
 
   # Whether this catalog was retrieved from the cache, which affects
   # whether it is written back out again.
   attr_accessor :from_cache
 
   # Some metadata to help us compile and generally respond to the current state.
   attr_accessor :client_version, :server_version
 
   # Add classes to our class list.
   def add_class(*classes)
     classes.each do |klass|
       @classes << klass
     end
 
     # Add the class names as tags, too.
     tag(*classes)
   end
 
   def title_key_for_ref( ref )
     ref =~ /^([-\w:]+)\[(.*)\]$/m
     [$1, $2]
   end
 
   # Add a resource to our graph and to our resource table.
   # This is actually a relatively complicated method, because it handles multiple
   # aspects of Catalog behaviour:
   # * Add the resource to the resource table
   # * Add the resource to the resource graph
   # * Add the resource to the relationship graph
   # * Add any aliases that make sense for the resource (e.g., name != title)
   def add_resource(*resource)
     add_resource(*resource[0..-2]) if resource.length > 1
     resource = resource.pop
     raise ArgumentError, "Can only add objects that respond to :ref, not instances of #{resource.class}" unless resource.respond_to?(:ref)
     fail_on_duplicate_type_and_title(resource)
     title_key = title_key_for_ref(resource.ref)
 
     @transient_resources << resource if applying?
     @resource_table[title_key] = resource
 
     # If the name and title differ, set up an alias
 
     if resource.respond_to?(:name) and resource.respond_to?(:title) and resource.respond_to?(:isomorphic?) and resource.name != resource.title
       self.alias(resource, resource.uniqueness_key) if resource.isomorphic?
     end
 
     resource.catalog = self if resource.respond_to?(:catalog=)
     add_vertex(resource)
     @relationship_graph.add_vertex(resource) if @relationship_graph
   end
 
   # Create an alias for a resource.
   def alias(resource, key)
     resource.ref =~ /^(.+)\[/
     class_name = $1 || resource.class.name
 
     newref = [class_name, key].flatten
 
     if key.is_a? String
       ref_string = "#{class_name}[#{key}]"
       return if ref_string == resource.ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
     # because sometimes an alias is created before the resource is
     # added to the catalog, so comparing inside the below if block
     # isn't sufficient.
     if existing = @resource_table[newref]
       return if existing == resource
       resource_declaration = " at #{resource.file}:#{resource.line}" if resource.file and resource.line
       existing_declaration = " at #{existing.file}:#{existing.line}" if existing.file and existing.line
       msg = "Cannot alias #{resource.ref} to #{key.inspect}#{resource_declaration}; resource #{newref.inspect} already declared#{existing_declaration}"
       raise ArgumentError, msg
     end
     @resource_table[newref] = resource
     @aliases[resource.ref] ||= []
     @aliases[resource.ref] << newref
   end
 
   # Apply our catalog to the local host.  Valid options
   # are:
   #   :tags - set the tags that restrict what resources run
   #       during the transaction
   #   :ignoreschedules - tell the transaction to ignore schedules
   #       when determining the resources to run
   def apply(options = {})
     @applying = true
 
     Puppet::Util::Storage.load if host_config?
 
     transaction = Puppet::Transaction.new(self, options[:report])
     register_report = options[:report].nil?
 
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
     transaction.for_network_device = options[:network_device]
 
     transaction.add_times :config_retrieval => self.retrieval_duration || 0
 
     begin
       Puppet::Util::Log.newdestination(transaction.report) if register_report
       begin
         transaction.evaluate
       ensure
         Puppet::Util::Log.close(transaction.report) if register_report
       end
     rescue Puppet::Error => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not apply complete catalog: #{detail}"
+      Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Got an uncaught exception of type #{detail.class}: #{detail}"
+      Puppet.log_exception(detail, "Got an uncaught exception of type #{detail.class}: #{detail}")
     ensure
       # Don't try to store state unless we're a host config
       # too recursive.
       Puppet::Util::Storage.store if host_config?
     end
 
     yield transaction if block_given?
 
     return transaction
   ensure
     @applying = false
   end
 
   # Are we in the middle of applying the catalog?
   def applying?
     @applying
   end
 
   def clear(remove_resources = true)
     super()
     # We have to do this so that the resources clean themselves up.
     @resource_table.values.each { |resource| resource.remove } if remove_resources
     @resource_table.clear
 
     if @relationship_graph
       @relationship_graph.clear
       @relationship_graph = nil
     end
   end
 
   def classes
     @classes.dup
   end
 
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
     unless klass = Puppet::Type.type(type)
       raise ArgumentError, "Unknown resource type #{type}"
     end
     return unless resource = klass.new(options)
 
     add_resource(resource)
     resource
   end
 
   # Make sure all of our resources are "finished".
   def finalize
     make_default_resources
 
     @resource_table.values.each { |resource| resource.finish }
 
     write_graph(:resources)
   end
 
   def host_config?
     host_config
   end
 
   def initialize(name = nil)
     super()
     @name = name if name
     @classes = []
     @resource_table = {}
     @transient_resources = []
     @applying = false
     @relationship_graph = nil
 
     @host_config = true
 
     @aliases = {}
 
     if block_given?
       yield(self)
       finalize
     end
   end
 
   # Make the default objects necessary for function.
   def make_default_resources
     # We have to add the resources to the catalog, or else they won't get cleaned up after
     # the transaction.
 
     # First create the default scheduling objects
     Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
 
     # And filebuckets
     if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
       add_resource(bucket) unless resource(bucket.ref)
     end
   end
 
   # Create a graph of all of the relationships in our catalog.
   def relationship_graph
     unless @relationship_graph
       # It's important that we assign the graph immediately, because
       # the debug messages below use the relationships in the
       # relationship graph to determine the path to the resources
       # spitting out the messages.  If this is not set,
       # then we get into an infinite loop.
       @relationship_graph = Puppet::SimpleGraph.new
 
       # First create the dependency graph
       self.vertices.each do |vertex|
         @relationship_graph.add_vertex vertex
         vertex.builddepends.each do |edge|
           @relationship_graph.add_edge(edge)
         end
       end
 
       # Lastly, add in any autorequires
       @relationship_graph.vertices.each do |vertex|
         vertex.autorequire(self).each do |edge|
           unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones.
             unless @relationship_graph.edge?(edge.target, edge.source)
               vertex.debug "Autorequiring #{edge.source}"
               @relationship_graph.add_edge(edge)
             else
               vertex.debug "Skipping automatic relationship with #{(edge.source == vertex ? edge.target : edge.source)}"
             end
           end
         end
       end
       @relationship_graph.write_graph(:relationships) if host_config?
 
       # Then splice in the container information
       splice!(@relationship_graph)
 
       @relationship_graph.write_graph(:expanded_relationships) if host_config?
     end
     @relationship_graph
   end
 
   # Impose our container information on another graph by using it
   # to replace any container vertices X with a pair of verticies
   # { admissible_X and completed_X } such that that
   #
   #    0) completed_X depends on admissible_X
   #    1) contents of X each depend on admissible_X
   #    2) completed_X depends on each on the contents of X
   #    3) everything which depended on X depens on completed_X
   #    4) admissible_X depends on everything X depended on
   #    5) the containers and their edges must be removed
   #
   # Note that this requires attention to the possible case of containers
   # which contain or depend on other containers, but has the advantage
   # that the number of new edges created scales linearly with the number
   # of contained verticies regardless of how containers are related;
   # alternatives such as replacing container-edges with content-edges
   # scale as the product of the number of external dependences, which is
   # to say geometrically in the case of nested / chained containers.
   #
   Default_label = { :callback => :refresh, :event => :ALL_EVENTS }
   def splice!(other)
     stage_class      = Puppet::Type.type(:stage)
     whit_class       = Puppet::Type.type(:whit)
     component_class  = Puppet::Type.type(:component)
     containers = vertices.find_all { |v| (v.is_a?(component_class) or v.is_a?(stage_class)) and vertex?(v) }
     #
     # These two hashes comprise the aforementioned attention to the possible
     #   case of containers that contain / depend on other containers; they map
     #   containers to their sentinels but pass other verticies through.  Thus we
     #   can "do the right thing" for references to other verticies that may or
     #   may not be containers.
     #
     admissible = Hash.new { |h,k| k }
     completed  = Hash.new { |h,k| k }
     containers.each { |x|
       admissible[x] = whit_class.new(:name => "admissible_#{x.ref}", :catalog => self)
       completed[x]  = whit_class.new(:name => "completed_#{x.ref}",  :catalog => self)
     }
     #
     # Implement the six requierments listed above
     #
     containers.each { |x|
       contents = adjacent(x, :direction => :out)
       other.add_edge(admissible[x],completed[x]) if contents.empty? # (0)
       contents.each { |v|
         other.add_edge(admissible[x],admissible[v],Default_label) # (1)
         other.add_edge(completed[v], completed[x], Default_label) # (2)
       }
       # (3) & (5)
       other.adjacent(x,:direction => :in,:type => :edges).each { |e|
         other.add_edge(completed[e.source],admissible[x],e.label)
         other.remove_edge! e
       }
       # (4) & (5)
       other.adjacent(x,:direction => :out,:type => :edges).each { |e|
         other.add_edge(completed[x],admissible[e.target],e.label)
         other.remove_edge! e
       }
     }
     containers.each { |x| other.remove_vertex! x } # (5)
   end
 
   # Remove the resource from our catalog.  Notice that we also call
   # 'remove' on the resource, at least until resource classes no longer maintain
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
       @resource_table.delete(resource.ref)
       if aliases = @aliases[resource.ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
         @aliases.delete(resource.ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       resource.remove
     end
   end
 
   # Look a resource up by its reference (e.g., File[/etc/passwd]).
   def resource(type, title = nil)
     # Always create a resource reference, so that it always canonizes how we
     # are referring to them.
     if title
       res = Puppet::Resource.new(type, title)
     else
       # If they didn't provide a title, then we expect the first
       # argument to be of the form 'Class[name]', which our
       # Reference class canonizes for us.
       res = Puppet::Resource.new(nil, type)
     end
     title_key      = [res.type, res.title.to_s]
     uniqueness_key = [res.type, res.uniqueness_key].flatten
     @resource_table[title_key] || @resource_table[uniqueness_key]
   end
 
   def resource_refs
     resource_keys.collect{ |type, name| name.is_a?( String ) ? "#{type}[#{name}]" : nil}.compact
   end
 
   def resource_keys
     @resource_table.keys
   end
 
   def resources
     @resource_table.values.uniq
   end
 
   def self.from_pson(data)
     result = new(data['name'])
 
     if tags = data['tags']
       result.tag(*tags)
     end
 
     if version = data['version']
       result.version = version
     end
 
     if resources = data['resources']
       resources = PSON.parse(resources) if resources.is_a?(String)
       resources.each do |res|
         resource_from_pson(result, res)
       end
     end
 
     if edges = data['edges']
       edges = PSON.parse(edges) if edges.is_a?(String)
       edges.each do |edge|
         edge_from_pson(result, edge)
       end
     end
 
     if classes = data['classes']
       result.add_class(*classes)
     end
 
     result
   end
 
   def self.edge_from_pson(result, edge)
     # If no type information was presented, we manually find
     # the class.
     edge = Puppet::Relationship.from_pson(edge) if edge.is_a?(Hash)
     unless source = result.resource(edge.source)
       raise ArgumentError, "Could not convert from pson: Could not find relationship source #{edge.source.inspect}"
     end
     edge.source = source
 
     unless target = result.resource(edge.target)
       raise ArgumentError, "Could not convert from pson: Could not find relationship target #{edge.target.inspect}"
     end
     edge.target = target
 
     result.add_edge(edge)
   end
 
   def self.resource_from_pson(result, res)
     res = Puppet::Resource.from_pson(res) if res.is_a? Hash
     result.add_resource(res)
   end
 
   PSON.register_document_type('Catalog',self)
   def to_pson_data_hash
     {
       'document_type' => 'Catalog',
       'data'       => {
         'tags'      => tags,
         'name'      => name,
         'version'   => version,
         'resources' => vertices.collect { |v| v.to_pson_data_hash },
         'edges'     => edges.   collect { |e| e.to_pson_data_hash },
         'classes'   => classes
         },
       'metadata' => {
         'api_version' => 1
         }
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Convert our catalog into a RAL catalog.
   def to_ral
     to_catalog :to_ral
   end
 
   # Convert our catalog into a catalog of Puppet::Resource instances.
   def to_resource
     to_catalog :to_resource
   end
 
   # filter out the catalog, applying +block+ to each resource.
   # If the block result is false, the resource will
   # be kept otherwise it will be skipped
   def filter(&block)
     to_catalog :to_resource, &block
   end
 
   # Store the classes in the classfile.
   def write_class_file
     ::File.open(Puppet[:classfile], "w") do |f|
       f.puts classes.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create class file #{Puppet[:classfile]}: #{detail}"
   end
 
   # Store the list of resources we manage
   def write_resource_file
     ::File.open(Puppet[:resourcefile], "w") do |f|
       to_print = resources.map do |resource|
         next unless resource.managed?
         if resource.name_var
           "#{resource.type}[#{resource[resource.name_var]}]"
         else
           "#{resource.ref.downcase}"
         end
       end.compact
       f.puts to_print.join("\n")
     end
   rescue => detail
     Puppet.err "Could not create resource file #{Puppet[:resourcefile]}: #{detail}"
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     # We only want to graph the main host catalog.
     return unless host_config?
 
     super
   end
 
   private
 
   # Verify that the given resource isn't declared elsewhere.
   def fail_on_duplicate_type_and_title(resource)
     # Short-curcuit the common case,
     return unless existing_resource = @resource_table[title_key_for_ref(resource.ref)]
 
     # If we've gotten this far, it's a real conflict
     msg = "Duplicate declaration: #{resource.ref} is already declared"
 
     msg << " in file #{existing_resource.file} at line #{existing_resource.line}" if existing_resource.file and existing_resource.line
 
     msg << "; cannot redeclare" if resource.line or resource.file
 
     raise DuplicateResourceError.new(msg)
   end
 
   # An abstracted method for converting one catalog into another type of catalog.
   # This pretty much just converts all of the resources from one class to another, using
   # a conversion method.
   def to_catalog(convert)
     result = self.class.new(self.name)
 
     result.version = self.version
 
     map = {}
     vertices.each do |resource|
       next if virtual_not_exported?(resource)
       next if block_given? and yield resource
 
       #This is hackity hack for 1094
       #Aliases aren't working in the ral catalog because the current instance of the resource
       #has a reference to the catalog being converted. . . So, give it a reference to the new one
       #problem solved. . .
       if resource.class == Puppet::Resource
         resource = resource.dup
         resource.catalog = result
       elsif resource.is_a?(Puppet::Parser::Resource)
         resource = resource.to_resource
         resource.catalog = result
       end
 
       if resource.is_a?(Puppet::Resource) and convert.to_s == "to_resource"
         newres = resource
       else
         newres = resource.send(convert)
       end
 
       # We can't guarantee that resources don't munge their names
       # (like files do with trailing slashes), so we have to keep track
       # of what a resource got converted to.
       map[resource.ref] = newres
 
       result.add_resource newres
     end
 
     message = convert.to_s.gsub "_", " "
     edges.each do |edge|
       # Skip edges between virtual resources.
       next if virtual_not_exported?(edge.source)
       next if block_given? and yield edge.source
 
       next if virtual_not_exported?(edge.target)
       next if block_given? and yield edge.target
 
       unless source = map[edge.source.ref]
         raise Puppet::DevError, "Could not find resource #{edge.source.ref} when converting #{message} resources"
       end
 
       unless target = map[edge.target.ref]
         raise Puppet::DevError, "Could not find resource #{edge.target.ref} when converting #{message} resources"
       end
 
       result.add_edge(source, target, edge.label)
     end
 
     map.clear
 
     result.add_class(*self.classes)
     result.tag(*self.tags)
 
     result
   end
 
   def virtual_not_exported?(resource)
     resource.respond_to?(:virtual?) and resource.virtual? and (resource.respond_to?(:exported?) and not resource.exported?)
   end
 end
diff --git a/lib/puppet/ssl/certificate_authority/interface.rb b/lib/puppet/ssl/certificate_authority/interface.rb
index 305d502cb..8a978b0b8 100644
--- a/lib/puppet/ssl/certificate_authority/interface.rb
+++ b/lib/puppet/ssl/certificate_authority/interface.rb
@@ -1,179 +1,178 @@
 # This class is basically a hidden class that knows how to act
 # on the CA.  It's only used by the 'puppetca' executable, and its
 # job is to provide a CLI-like interface to the CA class.
 module Puppet
   module SSL
     class CertificateAuthority
       class Interface
         INTERFACE_METHODS = [:destroy, :list, :revoke, :generate, :sign, :print, :verify, :fingerprint]
 
         class InterfaceError < ArgumentError; end
 
         attr_reader :method, :subjects, :digest, :options
 
         # Actually perform the work.
         def apply(ca)
           unless subjects or method == :list
             raise ArgumentError, "You must provide hosts or --all when using #{method}"
           end
 
           begin
             return send(method, ca) if respond_to?(method)
 
             (subjects == :all ? ca.list : subjects).each do |host|
               ca.send(method, host)
             end
           rescue InterfaceError
             raise
           rescue => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Could not call #{method}: #{detail}"
+            Puppet.log_exception(detail, "Could not call #{method}: #{detail}")
           end
         end
 
         def generate(ca)
           raise InterfaceError, "It makes no sense to generate all hosts; you must specify a list" if subjects == :all
 
           subjects.each do |host|
             ca.generate(host, options)
           end
         end
 
         def initialize(method, options)
           self.method = method
           self.subjects = options.delete(:to)
           @digest = options.delete(:digest) || :MD5
           @options = options
         end
 
         # List the hosts.
         def list(ca)
           signed = ca.list
           requests = ca.waiting?
 
           case subjects
           when :all
             hosts = [signed, requests].flatten
           when :signed
             hosts = signed.flatten
           when nil
             hosts = requests
           else
             hosts = subjects
           end
 
           certs = {:signed => {}, :invalid => {}, :request => {}}
 
           return if hosts.empty?
 
           hosts.uniq.sort.each do |host|
             begin
               ca.verify(host) unless requests.include?(host)
             rescue Puppet::SSL::CertificateAuthority::CertificateVerificationError => details
               verify_error = details.to_s
             end
 
             if verify_error
               cert = Puppet::SSL::Certificate.indirection.find(host)
               certs[:invalid][host] = [cert, verify_error]
             elsif signed.include?(host)
               cert = Puppet::SSL::Certificate.indirection.find(host)
               certs[:signed][host] = cert
             else
               req = Puppet::SSL::CertificateRequest.indirection.find(host)
               certs[:request][host] = req
             end
           end
 
           names = certs.values.map(&:keys).flatten
 
           name_width = names.sort_by(&:length).last.length rescue 0
 
           output = [:request, :signed, :invalid].map do |type|
             next if certs[type].empty?
 
             certs[type].map do |host,info|
               format_host(ca, host, type, info, name_width)
             end
           end.flatten.compact.sort.join("\n")
 
           puts output
         end
 
         def format_host(ca, host, type, info, width)
           certish, verify_error = info
           alt_names = case type
                       when :signed
                         certish.subject_alt_names
                       when :request
                         certish.subject_alt_names
                       else
                         []
                       end
 
           alt_names.delete(host)
 
           alt_str = "(alt names: #{alt_names.join(', ')})" unless alt_names.empty?
 
           glyph = {:signed => '+', :request => ' ', :invalid => '-'}[type]
 
           name = host.ljust(width)
           fingerprint = "(#{ca.fingerprint(host, @digest)})"
 
           explanation = "(#{verify_error})" if verify_error
 
           [glyph, name, fingerprint, alt_str, explanation].compact.join(' ')
         end
 
         # Set the method to apply.
         def method=(method)
           raise ArgumentError, "Invalid method #{method} to apply" unless INTERFACE_METHODS.include?(method)
           @method = method
         end
 
         # Print certificate information.
         def print(ca)
           (subjects == :all ? ca.list  : subjects).each do |host|
             if value = ca.print(host)
               puts value
             else
               Puppet.err "Could not find certificate for #{host}"
             end
           end
         end
 
         # Print certificate information.
         def fingerprint(ca)
           (subjects == :all ? ca.list + ca.waiting?: subjects).each do |host|
             if value = ca.fingerprint(host, @digest)
               puts "#{host} #{value}"
             else
               Puppet.err "Could not find certificate for #{host}"
             end
           end
         end
 
         # Sign a given certificate.
         def sign(ca)
           list = subjects == :all ? ca.waiting? : subjects
           raise InterfaceError, "No waiting certificate requests to sign" if list.empty?
           list.each do |host|
             ca.sign(host, options[:allow_dns_alt_names])
           end
         end
 
         # Set the list of hosts we're operating on.  Also supports keywords.
         def subjects=(value)
           unless value == :all or value == :signed or value.is_a?(Array)
             raise ArgumentError, "Subjects must be an array or :all; not #{value}"
           end
 
           value = nil if value.is_a?(Array) and value.empty?
 
           @subjects = value
         end
       end
     end
   end
 end
 
diff --git a/lib/puppet/ssl/host.rb b/lib/puppet/ssl/host.rb
index a4baf5b7c..b73423131 100644
--- a/lib/puppet/ssl/host.rb
+++ b/lib/puppet/ssl/host.rb
@@ -1,339 +1,337 @@
 require 'puppet/indirector'
 require 'puppet/ssl'
 require 'puppet/ssl/key'
 require 'puppet/ssl/certificate'
 require 'puppet/ssl/certificate_request'
 require 'puppet/ssl/certificate_revocation_list'
 
 # The class that manages all aspects of our SSL certificates --
 # private keys, public keys, requests, etc.
 class Puppet::SSL::Host
   # Yay, ruby's strange constant lookups.
   Key = Puppet::SSL::Key
   CA_NAME = Puppet::SSL::CA_NAME
   Certificate = Puppet::SSL::Certificate
   CertificateRequest = Puppet::SSL::CertificateRequest
   CertificateRevocationList = Puppet::SSL::CertificateRevocationList
 
   extend Puppet::Indirector
   indirects :certificate_status, :terminus_class => :file
 
   attr_reader :name
   attr_accessor :ca
 
   attr_writer :key, :certificate, :certificate_request
 
   # This accessor is used in instances for indirector requests to hold desired state
   attr_accessor :desired_state
 
   def self.localhost
     return @localhost if @localhost
     @localhost = new
     @localhost.generate unless @localhost.certificate
     @localhost.key
     @localhost
   end
 
   def self.reset
     @localhost = nil
   end
 
   # This is the constant that people will use to mark that a given host is
   # a certificate authority.
   def self.ca_name
     CA_NAME
   end
 
   class << self
     attr_reader :ca_location
   end
 
   # Configure how our various classes interact with their various terminuses.
   def self.configure_indirection(terminus, cache = nil)
     Certificate.indirection.terminus_class = terminus
     CertificateRequest.indirection.terminus_class = terminus
     CertificateRevocationList.indirection.terminus_class = terminus
 
     host_map = {:ca => :file, :file => nil, :rest => :rest}
     if term = host_map[terminus]
       self.indirection.terminus_class = term
     else
       self.indirection.reset_terminus_class
     end
 
     if cache
       # This is weird; we don't actually cache our keys, we
       # use what would otherwise be the cache as our normal
       # terminus.
       Key.indirection.terminus_class = cache
     else
       Key.indirection.terminus_class = terminus
     end
 
     if cache
       Certificate.indirection.cache_class = cache
       CertificateRequest.indirection.cache_class = cache
       CertificateRevocationList.indirection.cache_class = cache
     else
       # Make sure we have no cache configured.  puppet master
       # switches the configurations around a bit, so it's important
       # that we specify the configs for absolutely everything, every
       # time.
       Certificate.indirection.cache_class = nil
       CertificateRequest.indirection.cache_class = nil
       CertificateRevocationList.indirection.cache_class = nil
     end
   end
 
   CA_MODES = {
     # Our ca is local, so we use it as the ultimate source of information
     # And we cache files locally.
     :local => [:ca, :file],
     # We're a remote CA client.
     :remote => [:rest, :file],
     # We are the CA, so we don't have read/write access to the normal certificates.
     :only => [:ca],
     # We have no CA, so we just look in the local file store.
     :none => [:file]
   }
 
   # Specify how we expect to interact with our certificate authority.
   def self.ca_location=(mode)
     modes = CA_MODES.collect { |m, vals| m.to_s }.join(", ")
     raise ArgumentError, "CA Mode can only be one of: #{modes}" unless CA_MODES.include?(mode)
 
     @ca_location = mode
 
     configure_indirection(*CA_MODES[@ca_location])
   end
 
   # Puppet::SSL::Host is actually indirected now so the original implementation
   # has been moved into the certificate_status indirector.  This method is in-use
   # in `puppet cert -c <certname>`.
   def self.destroy(name)
     indirection.destroy(name)
   end
 
   def self.from_pson(pson)
     instance = new(pson["name"])
     if pson["desired_state"]
       instance.desired_state = pson["desired_state"]
     end
     instance
   end
 
   # Puppet::SSL::Host is actually indirected now so the original implementation
   # has been moved into the certificate_status indirector.  This method does not
   # appear to be in use in `puppet cert -l`.
   def self.search(options = {})
     indirection.search("*", options)
   end
 
   # Is this a ca host, meaning that all of its files go in the CA location?
   def ca?
     ca
   end
 
   def key
     @key ||= Key.indirection.find(name)
   end
 
   # This is the private key; we can create it from scratch
   # with no inputs.
   def generate_key
     @key = Key.new(name)
     @key.generate
     begin
       Key.indirection.save(@key)
     rescue
       @key = nil
       raise
     end
     true
   end
 
   def certificate_request
     @certificate_request ||= CertificateRequest.indirection.find(name)
   end
 
   def this_csr_is_for_the_current_host
     name == Puppet[:certname].downcase
   end
 
   def this_csr_is_for_the_current_host
     name == Puppet[:certname].downcase
   end
 
   # Our certificate request requires the key but that's all.
   def generate_certificate_request(options = {})
     generate_key unless key
 
     # If this is for the current machine...
     if this_csr_is_for_the_current_host
       # ...add our configured dns_alt_names
       if Puppet[:dns_alt_names] and Puppet[:dns_alt_names] != ''
         options[:dns_alt_names] ||= Puppet[:dns_alt_names]
       elsif Puppet::SSL::CertificateAuthority.ca? and fqdn = Facter.value(:fqdn) and domain = Facter.value(:domain)
         options[:dns_alt_names] = "puppet, #{fqdn}, puppet.#{domain}"
       end
     end
 
     @certificate_request = CertificateRequest.new(name)
     @certificate_request.generate(key.content, options)
     begin
       CertificateRequest.indirection.save(@certificate_request)
     rescue
       @certificate_request = nil
       raise
     end
 
     true
   end
 
   def certificate
     unless @certificate
       generate_key unless key
 
       # get the CA cert first, since it's required for the normal cert
       # to be of any use.
       return nil unless Certificate.indirection.find("ca") unless ca?
       return nil unless @certificate = Certificate.indirection.find(name)
 
       validate_certificate_with_key
     end
     @certificate
   end
 
   def validate_certificate_with_key
     raise Puppet::Error, "No certificate to validate." unless certificate
     raise Puppet::Error, "No private key with which to validate certificate with fingerprint: #{certificate.fingerprint}" unless key
     unless certificate.content.check_private_key(key.content)
       raise Puppet::Error, <<ERROR_STRING
 The certificate retrieved from the master does not match the agent's private key.
 Certificate fingerprint: #{certificate.fingerprint}
 To fix this, remove the certificate from both the master and the agent and then start a puppet run, which will automatically regenerate a certficate.
 On the master:
   puppet cert clean #{Puppet[:certname]}
 On the agent:
   rm -f #{Puppet[:hostcert]}
   puppet agent -t
 ERROR_STRING
     end
   end
 
   # Generate all necessary parts of our ssl host.
   def generate
     generate_key unless key
     generate_certificate_request unless certificate_request
 
     # If we can get a CA instance, then we're a valid CA, and we
     # should use it to sign our request; else, just try to read
     # the cert.
     if ! certificate and ca = Puppet::SSL::CertificateAuthority.instance
       ca.sign(self.name, true)
     end
   end
 
   def initialize(name = nil)
     @name = (name || Puppet[:certname]).downcase
     @key = @certificate = @certificate_request = nil
     @ca = (name == self.class.ca_name)
   end
 
   # Extract the public key from the private key.
   def public_key
     key.content.public_key
   end
 
   # Create/return a store that uses our SSL info to validate
   # connections.
   def ssl_store(purpose = OpenSSL::X509::PURPOSE_ANY)
     unless @ssl_store
       @ssl_store = OpenSSL::X509::Store.new
       @ssl_store.purpose = purpose
 
       # Use the file path here, because we don't want to cause
       # a lookup in the middle of setting our ssl connection.
       @ssl_store.add_file(Puppet[:localcacert])
 
       # If there's a CRL, add it to our store.
       if crl = Puppet::SSL::CertificateRevocationList.indirection.find(CA_NAME)
         @ssl_store.flags = OpenSSL::X509::V_FLAG_CRL_CHECK_ALL|OpenSSL::X509::V_FLAG_CRL_CHECK if Puppet.settings[:certificate_revocation]
         @ssl_store.add_crl(crl.content)
       end
       return @ssl_store
     end
     @ssl_store
   end
 
   def to_pson(*args)
     my_cert = Puppet::SSL::Certificate.indirection.find(name)
     pson_hash = { :name  => name }
 
     my_state = state
 
     pson_hash[:state] = my_state
     pson_hash[:desired_state] = desired_state if desired_state
 
     if my_state == 'requested'
       pson_hash[:fingerprint] = certificate_request.fingerprint
     else
       pson_hash[:fingerprint] = my_cert.fingerprint
     end
 
     pson_hash.to_pson(*args)
   end
 
   # Attempt to retrieve a cert, if we don't already have one.
   def wait_for_cert(time)
     begin
       return if certificate
       generate
       return if certificate
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not request certificate: #{detail}"
+      Puppet.log_exception(detail, "Could not request certificate: #{detail}")
       if time < 1
         puts "Exiting; failed to retrieve certificate and waitforcert is disabled"
         exit(1)
       else
         sleep(time)
       end
       retry
     end
 
     if time < 1
       puts "Exiting; no certificate found and waitforcert is disabled"
       exit(1)
     end
 
     while true
       sleep time
       begin
         break if certificate
         Puppet.notice "Did not receive certificate"
       rescue StandardError => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not request certificate: #{detail}"
+        Puppet.log_exception(detail, "Could not request certificate: #{detail}")
       end
     end
   end
 
   def state
     my_cert = Puppet::SSL::Certificate.indirection.find(name)
     if certificate_request
       return 'requested'
     end
 
     begin
       Puppet::SSL::CertificateAuthority.new.verify(my_cert)
       return 'signed'
     rescue Puppet::SSL::CertificateAuthority::CertificateVerificationError
       return 'revoked'
     end
   end
 end
 
 require 'puppet/ssl/certificate_authority'
diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb
index 6eb72e9fc..d0c426c25 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,493 +1,490 @@
 # the class that actually walks our resource/property tree, collects the changes,
 # and performs them
 
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/application'
 require 'digest/sha1'
 
 class Puppet::Transaction
   require 'puppet/transaction/event'
   require 'puppet/transaction/event_manager'
   require 'puppet/transaction/resource_harness'
   require 'puppet/resource/status'
 
   attr_accessor :component, :catalog, :ignoreschedules, :for_network_device
   attr_accessor :configurator
 
   # The report, once generated.
   attr_reader :report
 
   # Routes and stores any events and subscriptions.
   attr_reader :event_manager
 
   # Handles most of the actual interacting with resources
   attr_reader :resource_harness
 
   include Puppet::Util
   include Puppet::Util::Tagging
 
   # Wraps application run state check to flag need to interrupt processing
   def stop_processing?
     Puppet::Application.stop_requested?
   end
 
   # Add some additional times for reporting
   def add_times(hash)
     hash.each do |name, num|
       report.add_times(name, num)
     end
   end
 
   # Are there any failed resources in this transaction?
   def any_failed?
     report.resource_statuses.values.detect { |status| status.failed? }
   end
 
   # Apply all changes for a resource
   def apply(resource, ancestor = nil)
     status = resource_harness.evaluate(resource)
     add_resource_status(status)
     event_manager.queue_events(ancestor || resource, status.events) unless status.failed?
   rescue => detail
     resource.err "Could not evaluate: #{detail}"
   end
 
   # Find all of the changed resources.
   def changed?
     report.resource_statuses.values.find_all { |status| status.changed }.collect { |status| catalog.resource(status.resource) }
   end
 
   # Find all of the applied resources (including failed attempts).
   def applied_resources
     report.resource_statuses.values.collect { |status| catalog.resource(status.resource) }
   end
 
   # Copy an important relationships from the parent to the newly-generated
   # child resource.
   def add_conditional_directed_dependency(parent, child, label=nil)
     relationship_graph.add_vertex(child)
     edge = parent.depthfirst? ? [child, parent] : [parent, child]
     if relationship_graph.edge?(*edge.reverse)
       parent.debug "Skipping automatic relationship to #{child}"
     else
       relationship_graph.add_edge(edge[0],edge[1],label)
     end
   end
 
   # Evaluate a single resource.
   def eval_resource(resource, ancestor = nil)
     if skip?(resource)
       resource_status(resource).skipped = true
     else
       resource_status(resource).scheduled = true
       apply(resource, ancestor)
     end
 
     # Check to see if there are any events queued for this resource
     event_manager.process_events(resource)
   end
 
   # This method does all the actual work of running a transaction.  It
   # collects all of the changes, executes them, and responds to any
   # necessary events.
   def evaluate
     add_dynamically_generated_resources
 
     Puppet.info "Applying configuration version '#{catalog.version}'" if catalog.version
 
     relationship_graph.traverse do |resource|
       if resource.is_a?(Puppet::Type::Component)
         Puppet.warning "Somehow left a component in the relationship graph"
       else
         resource.info "Starting to evaluate the resource" if Puppet[:evaltrace] and @catalog.host_config?
         seconds = thinmark { eval_resource(resource) }
         resource.info "Evaluated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
       end
     end
 
     Puppet.debug "Finishing transaction #{object_id}"
   end
 
   def events
     event_manager.events
   end
 
   def failed?(resource)
     s = resource_status(resource) and s.failed?
   end
 
   # Does this resource have any failed dependencies?
   def failed_dependencies?(resource)
     # First make sure there are no failed dependencies.  To do this,
     # we check for failures in any of the vertexes above us.  It's not
     # enough to check the immediate dependencies, which is why we use
     # a tree from the reversed graph.
     found_failed = false
 
 
     # When we introduced the :whit into the graph, to reduce the combinatorial
     # explosion of edges, we also ended up reporting failures for containers
     # like class and stage.  This is undesirable; while just skipping the
     # output isn't perfect, it is RC-safe. --daniel 2011-06-07
     suppress_report = (resource.class == Puppet::Type.type(:whit))
 
     relationship_graph.dependencies(resource).each do |dep|
       next unless failed?(dep)
       found_failed = true
 
       # See above. --daniel 2011-06-06
       unless suppress_report then
         resource.notice "Dependency #{dep} has failures: #{resource_status(dep).failed}"
       end
     end
 
     found_failed
   end
 
   def eval_generate(resource)
     return false unless resource.respond_to?(:eval_generate)
     raise Puppet::DevError,"Depthfirst resources are not supported by eval_generate" if resource.depthfirst?
     begin
       made = resource.eval_generate.uniq
       return false if made.empty?
       made = made.inject({}) {|a,v| a.merge(v.name => v) }
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      resource.err "Failed to generate additional resources using 'eval_generate: #{detail}"
+      resource.log_exception(detail, "Failed to generate additional resources using 'eval_generate: #{detail}")
       return false
     end
     made.values.each do |res|
       begin
         res.tag(*resource.tags)
         @catalog.add_resource(res)
         res.finish
       rescue Puppet::Resource::Catalog::DuplicateResourceError
         res.info "Duplicate generated resource; skipping"
       end
     end
     sentinel = Puppet::Type.type(:whit).new(:name => "completed_#{resource.title}", :catalog => resource.catalog)
 
     # The completed whit is now the thing that represents the resource is done
     relationship_graph.adjacent(resource,:direction => :out,:type => :edges).each { |e|
       # But children run as part of the resource, not after it
       next if made[e.target.name]
 
       add_conditional_directed_dependency(sentinel, e.target, e.label)
       relationship_graph.remove_edge! e
     }
 
     default_label = Puppet::Resource::Catalog::Default_label
     made.values.each do |res|
       # Depend on the nearest ancestor we generated, falling back to the
       # resource if we have none
       parent_name = res.ancestors.find { |a| made[a] and made[a] != res }
       parent = made[parent_name] || resource
 
       add_conditional_directed_dependency(parent, res)
 
       # This resource isn't 'completed' until each child has run
       add_conditional_directed_dependency(res, sentinel, default_label)
     end
 
     # This edge allows the resource's events to propagate, though it isn't
     # strictly necessary for ordering purposes
     add_conditional_directed_dependency(resource, sentinel, default_label)
     true
   end
 
   # A general method for recursively generating new resources from a
   # resource.
   def generate_additional_resources(resource)
     return unless resource.respond_to?(:generate)
     begin
       made = resource.generate
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      resource.err "Failed to generate additional resources using 'generate': #{detail}"
+      resource.log_exception(detail, "Failed to generate additional resources using 'generate': #{detail}")
     end
     return unless made
     made = [made] unless made.is_a?(Array)
     made.uniq.each do |res|
       begin
         res.tag(*resource.tags)
         @catalog.add_resource(res)
         res.finish
         add_conditional_directed_dependency(resource, res)
         generate_additional_resources(res)
       rescue Puppet::Resource::Catalog::DuplicateResourceError
         res.info "Duplicate generated resource; skipping"
       end
     end
   end
 
   def add_dynamically_generated_resources
     @catalog.vertices.each { |resource| generate_additional_resources(resource) }
   end
 
   # Should we ignore tags?
   def ignore_tags?
     ! (@catalog.host_config? or Puppet[:name] == "puppet")
   end
 
   # this should only be called by a Puppet::Type::Component resource now
   # and it should only receive an array
   def initialize(catalog, report = nil)
     @catalog = catalog
 
     @report = report || Puppet::Transaction::Report.new("apply", catalog.version, Puppet[:environment])
 
     @event_manager = Puppet::Transaction::EventManager.new(self)
 
     @resource_harness = Puppet::Transaction::ResourceHarness.new(self)
 
     @prefetched_providers = Hash.new { |h,k| h[k] = {} }
   end
 
   def resources_by_provider(type_name, provider_name)
     unless @resources_by_provider
       @resources_by_provider = Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
 
       @catalog.vertices.each do |resource|
         if resource.class.attrclass(:provider)
           prov = resource.provider && resource.provider.class.name
           @resources_by_provider[resource.type][prov][resource.name] = resource
         end
       end
     end
 
     @resources_by_provider[type_name][provider_name] || {}
   end
 
   def prefetch_if_necessary(resource)
     provider_class = resource.provider.class
     return unless provider_class.respond_to?(:prefetch) and !prefetched_providers[resource.type][provider_class.name]
 
     resources = resources_by_provider(resource.type, provider_class.name)
 
     if provider_class == resource.class.defaultprovider
       providerless_resources = resources_by_provider(resource.type, nil)
       providerless_resources.values.each {|res| res.provider = provider_class.name}
       resources.merge! providerless_resources
     end
 
     prefetch(provider_class, resources)
   end
 
   attr_reader :prefetched_providers
 
   # Prefetch any providers that support it, yo.  We don't support prefetching
   # types, just providers.
   def prefetch(provider_class, resources)
     type_name = provider_class.resource_type.name
     return if @prefetched_providers[type_name][provider_class.name]
     Puppet.debug "Prefetching #{provider_class.name} resources for #{type_name}"
     begin
       provider_class.prefetch(resources)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      Puppet.err "Could not prefetch #{type_name} provider '#{provider_class.name}': #{detail}"
+      Puppet.log_exception(detail, "Could not prefetch #{type_name} provider '#{provider_class.name}': #{detail}")
     end
     @prefetched_providers[type_name][provider_class.name] = true
   end
 
   # We want to monitor changes in the relationship graph of our
   # catalog but this is complicated by the fact that the catalog
   # both is_a graph and has_a graph, by the fact that changes to
   # the structure of the object can have adverse serialization
   # effects, by threading issues, by order-of-initialization issues,
   # etc.
   #
   # Since the proper lifetime/scope of the monitoring is a transaction
   # and the transaction is already commiting a mild law-of-demeter
   # transgression, we cut the Gordian knot here by simply wrapping the
   # transaction's view of the resource graph to capture and maintain
   # the information we need.  Nothing outside the transaction needs
   # this information, and nothing outside the transaction can see it
   # except via the Transaction#relationship_graph
 
   class Relationship_graph_wrapper
     require 'puppet/rb_tree_map'
     attr_reader :real_graph,:transaction,:ready,:generated,:done,:blockers,:unguessable_deterministic_key
     def initialize(real_graph,transaction)
       @real_graph = real_graph
       @transaction = transaction
       @ready = Puppet::RbTreeMap.new
       @generated = {}
       @done = {}
       @blockers = {}
       @unguessable_deterministic_key = Hash.new { |h,k| h[k] = Digest::SHA1.hexdigest("NaCl, MgSO4 (salts) and then #{k.ref}") }
       @providerless_types = []
     end
     def method_missing(*args,&block)
       real_graph.send(*args,&block)
     end
     def add_vertex(v)
       real_graph.add_vertex(v)
     end
     def add_edge(f,t,label=nil)
       key = unguessable_deterministic_key[t]
 
       ready.delete(key)
 
       real_graph.add_edge(f,t,label)
     end
     # Enqueue the initial set of resources, those with no dependencies.
     def enqueue_roots
       vertices.each do |v|
         blockers[v] = direct_dependencies_of(v).length
         enqueue(v) if blockers[v] == 0
       end
     end
     # Decrement the blocker count for the resource by 1. If the number of
     # blockers is unknown, count them and THEN decrement by 1.
     def unblock(resource)
       blockers[resource] ||= direct_dependencies_of(resource).select { |r2| !done[r2] }.length
       if blockers[resource] > 0
         blockers[resource] -= 1
       else
         resource.warning "appears to have a negative number of dependencies"
       end
       blockers[resource] <= 0
     end
     def enqueue(*resources)
       resources.each do |resource|
         key = unguessable_deterministic_key[resource]
         ready[key] = resource
       end
     end
     def finish(resource)
       direct_dependents_of(resource).each do |v|
         enqueue(v) if unblock(v)
       end
       done[resource] = true
     end
     def next_resource
       ready.delete_min
     end
     def traverse(&block)
       real_graph.report_cycles_in_graph
 
       enqueue_roots
 
       deferred_resources = []
 
       while (resource = next_resource) && !transaction.stop_processing?
         if resource.suitable?
           made_progress = true
 
           transaction.prefetch_if_necessary(resource)
 
           # If we generated resources, we don't know what they are now
           # blocking, so we opt to recompute it, rather than try to track every
           # change that would affect the number.
           blockers.clear if transaction.eval_generate(resource)
 
           yield resource
 
           finish(resource)
         else
           deferred_resources << resource
         end
 
         if ready.empty? and deferred_resources.any?
           if made_progress
             enqueue(*deferred_resources)
           else
             fail_unsuitable_resources(deferred_resources)
           end
 
           made_progress = false
           deferred_resources = []
         end
       end
 
       # Just once per type. No need to punish the user.
       @providerless_types.uniq.each do |type|
         Puppet.err "Could not find a suitable provider for #{type}"
       end
     end
 
     def fail_unsuitable_resources(resources)
       resources.each do |resource|
         # We don't automatically assign unsuitable providers, so if there
         # is one, it must have been selected by the user.
         if resource.provider
           resource.err "Provider #{resource.provider.class.name} is not functional on this host"
         else
           @providerless_types << resource.type
         end
 
         transaction.resource_status(resource).failed = true
 
         finish(resource)
       end
     end
   end
 
   def relationship_graph
     @relationship_graph ||= Relationship_graph_wrapper.new(catalog.relationship_graph,self)
   end
 
   def add_resource_status(status)
     report.add_resource_status status
   end
 
   def resource_status(resource)
     report.resource_statuses[resource.to_s] || add_resource_status(Puppet::Resource::Status.new(resource))
   end
 
   # Is the resource currently scheduled?
   def scheduled?(resource)
     self.ignoreschedules or resource_harness.scheduled?(resource_status(resource), resource)
   end
 
   # Should this resource be skipped?
   def skip?(resource)
     if missing_tags?(resource)
       resource.debug "Not tagged with #{tags.join(", ")}"
     elsif ! scheduled?(resource)
       resource.debug "Not scheduled"
     elsif failed_dependencies?(resource)
       # When we introduced the :whit into the graph, to reduce the combinatorial
       # explosion of edges, we also ended up reporting failures for containers
       # like class and stage.  This is undesirable; while just skipping the
       # output isn't perfect, it is RC-safe. --daniel 2011-06-07
       unless resource.class == Puppet::Type.type(:whit) then
         resource.warning "Skipping because of failed dependencies"
       end
     elsif resource.virtual?
       resource.debug "Skipping because virtual"
     elsif resource.appliable_to_device? ^ for_network_device
       resource.debug "Skipping #{resource.appliable_to_device? ? 'device' : 'host'} resources because running on a #{for_network_device ? 'device' : 'host'}"
     else
       return false
     end
     true
   end
 
   # The tags we should be checking.
   def tags
     self.tags = Puppet[:tags] unless defined?(@tags)
 
     super
   end
 
   def handle_qualified_tags( qualified )
     # The default behavior of Puppet::Util::Tagging is
     # to split qualified tags into parts. That would cause
     # qualified tags to match too broadly here.
     return
   end
 
   # Is this resource tagged appropriately?
   def missing_tags?(resource)
     return false if ignore_tags?
     return false if tags.empty?
 
     not resource.tagged?(*tags)
   end
 end
 
 require 'puppet/transaction/report'
 
diff --git a/lib/puppet/transaction/event_manager.rb b/lib/puppet/transaction/event_manager.rb
index c833235d4..b5106f24c 100644
--- a/lib/puppet/transaction/event_manager.rb
+++ b/lib/puppet/transaction/event_manager.rb
@@ -1,115 +1,115 @@
 require 'puppet/transaction'
 
 class Puppet::Transaction::EventManager
   attr_reader :transaction, :events
 
   def initialize(transaction)
     @transaction = transaction
     @event_queues = {}
     @events = []
   end
 
   def relationship_graph
     transaction.relationship_graph
   end
 
   # Respond to any queued events for this resource.
   def process_events(resource)
     restarted = false
     queued_events(resource) do |callback, events|
       r = process_callback(resource, callback, events)
       restarted ||= r
     end
 
     if restarted
       queue_events(resource, [resource.event(:name => :restarted, :status => "success")])
 
       transaction.resource_status(resource).restarted = true
     end
   end
 
   # Queue events for other resources to respond to.  All of these events have
   # to be from the same resource.
   def queue_events(resource, events)
     #@events += events
 
     # Do some basic normalization so we're not doing so many
     # graph queries for large sets of events.
     events.inject({}) do |collection, event|
       collection[event.name] ||= []
       collection[event.name] << event
       collection
     end.collect do |name, list|
       # It doesn't matter which event we use - they all have the same source
       # and name here.
       event = list[0]
 
       # Collect the targets of any subscriptions to those events.  We pass
       # the parent resource in so it will override the source in the events,
       # since eval_generated children can't have direct relationships.
       received = (event.name != :restarted)
       relationship_graph.matching_edges(event, resource).each do |edge|
         received ||= true unless edge.target.is_a?(Puppet::Type.type(:whit))
         next unless method = edge.callback
         next unless edge.target.respond_to?(method)
 
         queue_events_for_resource(resource, edge.target, method, list)
       end
       @events << event if received
 
       queue_events_for_resource(resource, resource, :refresh, [event]) if resource.self_refresh? and ! resource.deleting?
     end
   end
 
   def queue_events_for_resource(source, target, callback, events)
     whit = Puppet::Type.type(:whit)
 
     # The message that a resource is refreshing the completed-whit for its own class
     # is extremely counter-intuitive. Basically everything else is easy to understand,
     # if you suppress the whit-lookingness of the whit resources
     refreshing_c_whit = target.is_a?(whit) && target.name =~ /^completed_/
 
     if refreshing_c_whit
       source.debug "The container #{target} will propagate my #{callback} event"
     else
       source.info "Scheduling #{callback} of #{target}"
     end
 
     @event_queues[target] ||= {}
     @event_queues[target][callback] ||= []
     @event_queues[target][callback].concat(events)
   end
 
   def queued_events(resource)
     return unless callbacks = @event_queues[resource]
     callbacks.each do |callback, events|
       yield callback, events
     end
   end
 
   private
 
   def process_callback(resource, callback, events)
     process_noop_events(resource, callback, events) and return false unless events.detect { |e| e.status != "noop" }
     resource.send(callback)
 
     if not resource.is_a?(Puppet::Type.type(:whit))
       resource.notice "Triggered '#{callback}' from #{events.length} events"
     end
     return true
   rescue => detail
     resource.err "Failed to call #{callback}: #{detail}"
 
     transaction.resource_status(resource).failed_to_restart = true
-    puts detail.backtrace if Puppet[:trace]
+    resource.log_exception(detail)
     return false
   end
 
   def process_noop_events(resource, callback, events)
     resource.notice "Would have triggered '#{callback}' from #{events.length} events"
 
     # And then add an event for it.
     queue_events(resource, [resource.event(:status => "noop", :name => :noop_restart)])
     true # so the 'and if' works
   end
 end
diff --git a/lib/puppet/transaction/resource_harness.rb b/lib/puppet/transaction/resource_harness.rb
index 4a3d35e0d..1ae305661 100644
--- a/lib/puppet/transaction/resource_harness.rb
+++ b/lib/puppet/transaction/resource_harness.rb
@@ -1,178 +1,177 @@
 require 'puppet/resource/status'
 
 class Puppet::Transaction::ResourceHarness
   extend Forwardable
   def_delegators :@transaction, :relationship_graph
 
   attr_reader :transaction
 
   def allow_changes?(resource)
     if resource.purging? and resource.deleting? and deps = relationship_graph.dependents(resource) \
             and ! deps.empty? and deps.detect { |d| ! d.deleting? }
       deplabel = deps.collect { |r| r.ref }.join(",")
       plurality = deps.length > 1 ? "":"s"
       resource.warning "#{deplabel} still depend#{plurality} on me -- not purging"
       false
     else
       true
     end
   end
 
   # Used mostly for scheduling and auditing at this point.
   def cached(resource, name)
     Puppet::Util::Storage.cache(resource)[name]
   end
 
   # Used mostly for scheduling and auditing at this point.
   def cache(resource, name, value)
     Puppet::Util::Storage.cache(resource)[name] = value
   end
 
   def perform_changes(resource)
     current = resource.retrieve_resource
 
     cache resource, :checked, Time.now
 
     return [] if ! allow_changes?(resource)
 
     current_values = current.to_hash
     historical_values = Puppet::Util::Storage.cache(resource).dup
     desired_values = {}
     resource.properties.each do |property|
       desired_values[property.name] = property.should
     end
     audited_params = (resource[:audit] || []).map { |p| p.to_sym }
     synced_params = []
 
     # Record the current state in state.yml.
     audited_params.each do |param|
       cache(resource, param, current_values[param])
     end
 
     # Update the machine state & create logs/events
     events = []
     ensure_param = resource.parameter(:ensure)
     if desired_values[:ensure] && !ensure_param.safe_insync?(current_values[:ensure])
       events << apply_parameter(ensure_param, current_values[:ensure], audited_params.include?(:ensure), historical_values[:ensure])
       synced_params << :ensure
     elsif current_values[:ensure] != :absent
       work_order = resource.properties # Note: only the resource knows what order to apply changes in
       work_order.each do |param|
         if desired_values[param.name] && !param.safe_insync?(current_values[param.name])
           events << apply_parameter(param, current_values[param.name], audited_params.include?(param.name), historical_values[param.name])
           synced_params << param.name
         end
       end
     end
 
     # Add more events to capture audit results
     audited_params.each do |param_name|
       if historical_values.include?(param_name)
         if historical_values[param_name] != current_values[param_name] && !synced_params.include?(param_name)
           event = create_change_event(resource.parameter(param_name), current_values[param_name], true, historical_values[param_name])
           event.send_log
           events << event
         end
       else
         resource.property(param_name).notice "audit change: newly-recorded value #{current_values[param_name]}"
       end
     end
 
     events
   end
 
   def create_change_event(property, current_value, do_audit, historical_value)
     event = property.event
     event.previous_value = current_value
     event.desired_value = property.should
     event.historical_value = historical_value
 
     if do_audit
       event.audited = true
       event.status = "audit"
       if historical_value != current_value
         event.message = "audit change: previously recorded value #{property.is_to_s(historical_value)} has been changed to #{property.is_to_s(current_value)}"
       end
     end
 
     event
   end
 
   def apply_parameter(property, current_value, do_audit, historical_value)
     event = create_change_event(property, current_value, do_audit, historical_value)
 
     if do_audit && historical_value && historical_value != current_value
       brief_audit_message = " (previously recorded value was #{property.is_to_s(historical_value)})"
     else
       brief_audit_message = ""
     end
 
     if property.noop
       event.message = "current_value #{property.is_to_s(current_value)}, should be #{property.should_to_s(property.should)} (noop)#{brief_audit_message}"
       event.status = "noop"
     else
       property.sync
       event.message = [ property.change_to_s(current_value, property.should), brief_audit_message ].join
       event.status = "success"
     end
     event
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
+    Puppet.log_exception(detail)
     event.status = "failure"
 
     event.message = "change from #{property.is_to_s(current_value)} to #{property.should_to_s(property.should)} failed: #{detail}"
     event
   ensure
     event.send_log
   end
 
   def evaluate(resource)
     start = Time.now
     status = Puppet::Resource::Status.new(resource)
 
     perform_changes(resource).each do |event|
       status << event
     end
 
     if status.changed? && ! resource.noop?
       cache(resource, :synced, Time.now)
       resource.flush if resource.respond_to?(:flush)
     end
 
     return status
   rescue => detail
     resource.fail "Could not create resource status: #{detail}" unless status
-    puts detail.backtrace if Puppet[:trace]
-    resource.err "Could not evaluate: #{detail}"
+    resource.log_exception(detail, "Could not evaluate: #{detail}")
     status.failed = true
     return status
   ensure
     (status.evaluation_time = Time.now - start) if status
   end
 
   def initialize(transaction)
     @transaction = transaction
   end
 
   def scheduled?(status, resource)
     return true if Puppet[:ignoreschedules]
     return true unless schedule = schedule(resource)
 
     # We use 'checked' here instead of 'synced' because otherwise we'll
     # end up checking most resources most times, because they will generally
     # have been synced a long time ago (e.g., a file only gets updated
     # once a month on the server and its schedule is daily; the last sync time
     # will have been a month ago, so we'd end up checking every run).
     schedule.match?(cached(resource, :checked).to_i)
   end
 
   def schedule(resource)
     unless resource.catalog
       resource.warning "Cannot schedule without a schedule-containing catalog"
       return nil
     end
 
     return nil unless name = resource[:schedule]
     resource.catalog.resource(:schedule, name) || resource.fail("Could not find schedule #{name}")
   end
 end
diff --git a/lib/puppet/type/filebucket.rb b/lib/puppet/type/filebucket.rb
index 6fe15ca7e..af7dffc32 100755
--- a/lib/puppet/type/filebucket.rb
+++ b/lib/puppet/type/filebucket.rb
@@ -1,102 +1,103 @@
 module Puppet
   require 'puppet/file_bucket/dipper'
 
   newtype(:filebucket) do
     @doc = "A repository for backing up files.  If no filebucket is
       defined, then files will be backed up in their current directory,
       but the filebucket can be either a host- or site-global repository
       for backing up.  It stores files and returns the MD5 sum, which
       can later be used to retrieve the file if restoration becomes
       necessary.  A filebucket does not do any work itself; instead,
       it can be specified as the value of *backup* in a **file** object.
 
       Currently, filebuckets are only useful for manual retrieval of
       accidentally removed files (e.g., you look in the log for the md5 sum
       and retrieve the file with that sum from the filebucket), but when
       transactions are fully supported filebuckets will be used to undo
       transactions.
 
       You will normally want to define a single filebucket for your
       whole network and then use that as the default backup location:
 
           # Define the bucket
           filebucket { 'main':
             server => puppet,
             path   => false,
             # Due to a known issue, path must be set to false for remote filebuckets.
           }
 
           # Specify it as the default target
           File { backup => main }
 
       Puppetmaster servers create a filebucket by default, so this will
       work in a default configuration."
 
     newparam(:name) do
       desc "The name of the filebucket."
       isnamevar
     end
 
     newparam(:server) do
       desc "The server providing the remote filebucket.  If this is not
         specified then *path* is checked. If it is set, then the
         bucket is local.  Otherwise the puppetmaster server specified
         in the config or at the commandline is used.
 
         Due to a known issue, you currently must set the `path` attribute to
         false if you wish to specify a `server` attribute."
       defaultto { Puppet[:server] }
     end
 
     newparam(:port) do
       desc "The port on which the remote server is listening.
         Defaults to the normal Puppet port, %s." % Puppet[:masterport]
 
       defaultto { Puppet[:masterport] }
     end
 
     newparam(:path) do
       desc "The path to the local filebucket.  If this is
         unset, then the bucket is remote.  The parameter *server* must
         can be specified to set the remote server."
 
       defaultto { Puppet[:clientbucketdir] }
     end
 
     # Create a default filebucket.
     def self.mkdefaultbucket
       new(:name => "puppet", :path => Puppet[:clientbucketdir])
     end
 
     def bucket
       mkbucket unless defined?(@bucket)
       @bucket
     end
 
     private
 
     def mkbucket
       # Default is a local filebucket, if no server is given.
       # If the default path has been removed, too, then
       # the puppetmaster is used as default server
 
       type = "local"
       args = {}
       if self[:path]
         args[:Path] = self[:path]
       else
         args[:Server] = self[:server]
         args[:Port] = self[:port]
       end
 
       begin
         @bucket = Puppet::FileBucket::Dipper.new(args)
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        self.fail("Could not create #{type} filebucket: #{detail}")
+        message = "Could not create #{type} filebucket: #{detail}"
+        self.log_exception(detail, message)
+        self.fail(message)
       end
 
       @bucket.name = self.name
     end
   end
 end
diff --git a/lib/puppet/util/autoload.rb b/lib/puppet/util/autoload.rb
index 2e8710ab1..414265805 100644
--- a/lib/puppet/util/autoload.rb
+++ b/lib/puppet/util/autoload.rb
@@ -1,156 +1,158 @@
 require 'puppet/util/warnings'
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
   require 'puppet/util/autoload/file_cache'
 
   include Puppet::Util
   include Puppet::Util::Warnings
   include Puppet::Util::Autoload::FileCache
 
   @autoloaders = {}
   @loaded = []
 
   class << self
     attr_reader :autoloaders
     private :autoloaders
   end
 
   # Send [], []=, and :clear to the @autloaders hash
   Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
 
   # List all loaded files.
   def self.list_loaded
     @loaded.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
       "#{path}: #{hash[:file]}"
     end
   end
 
   # Has a given path been loaded?  This is used for testing whether a
   # changed file should be loaded or just ignored.  This is only
   # used in network/client/master, when downloading plugins, to
   # see if a given plugin is currently loaded and thus should be
   # reloaded.
   def self.loaded?(path)
     path = path.to_s.sub(/\.rb$/, '')
     @loaded.include?(path)
   end
 
   # Save the fact that a given path has been loaded.  This is so
   # we can load downloaded plugins if they've already been loaded
   # into memory.
   def self.loaded(file)
     $" << file + ".rb" unless $".include?(file)
     @loaded << file unless @loaded.include?(file)
   end
 
   attr_accessor :object, :path, :objwarn, :wrap
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if @path !~ /^\w/
     @object = obj
 
     self.class[obj] = self
 
     options.each do |opt, value|
       opt = opt.intern if opt.is_a? String
       begin
         self.send(opt.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "#{opt} is not a valid option"
       end
     end
 
     @wrap = true unless defined?(@wrap)
   end
 
   # Load a single plugin by name.  We use 'load' here so we can reload a
   # given plugin.
   def load(name,env=nil)
     path = name.to_s + ".rb"
 
     searchpath(env).each do |dir|
       file = File.join(dir, path)
       next unless file_exist?(file)
       begin
         Kernel.load file, @wrap
         name = symbolize(name)
         loaded name, file
         return true
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
-        puts detail.backtrace if Puppet[:trace]
-        raise Puppet::Error, "Could not autoload #{name}: #{detail}"
+        message = "Could not autoload #{name}: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message
       end
     end
     false
   end
 
   # Mark the named object as loaded.  Note that this supports unqualified
   # queries, while we store the result as a qualified query in the class.
   def loaded(name, file)
     self.class.loaded(File.join(@path, name.to_s))
   end
 
   # Indicate whether the specfied plugin has been loaded.
   def loaded?(name)
     self.class.loaded?(File.join(@path, name.to_s))
   end
 
   # Load all instances that we can.  This uses require, rather than load,
   # so that already-loaded files don't get reloaded unnecessarily.
   def loadall
     # Load every instance of everything we can find.
     files_to_load.each do |file|
       name = File.basename(file).chomp(".rb").intern
       next if loaded?(name)
       begin
         Kernel.require file
         loaded(name, file)
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
-        puts detail.backtrace if Puppet[:trace]
-        raise Puppet::Error, "Could not autoload #{file}: #{detail}"
+        message = "Could not autoload #{file}: #{detail}"
+        Puppet.log_exception(detail, message)
+        raise Puppet::Error, message
       end
     end
   end
 
   def files_to_load
     searchpath.map { |dir| Dir.glob("#{dir}/*.rb") }.flatten
   end
 
   # The list of directories to search through for loadable plugins.
   def searchpath(env=nil)
     search_directories(env).uniq.collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
   end
 
   def module_directories(env=nil)
     # We have to require this late in the process because otherwise we might have
     # load order issues.
     require 'puppet/node/environment'
 
     real_env = Puppet::Node::Environment.new(env)
 
     # We're using a per-thread cache of said module directories, so that
     # we don't scan the filesystem each time we try to load something with
     # this autoload instance. But since we don't want to cache for the eternity
     # this env_module_directories gets reset after the compilation on the master.
     # This is also reset after an agent ran.
     # One of the side effect of this change is that this module directories list will be
     # shared among all autoload that we have running at a time. But that won't be an issue
     # as by definition those directories are shared by all autoload.
     Thread.current[:env_module_directories] ||= {}
     Thread.current[:env_module_directories][real_env] ||= real_env.modulepath.collect do |dir|
         Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f) }
       end.flatten.collect { |d| [File.join(d, "plugins"), File.join(d, "lib")] }.flatten.find_all do |d|
         FileTest.directory?(d)
       end
   end
 
   def search_directories(env=nil)
     [module_directories(env), Puppet[:libdir].split(File::PATH_SEPARATOR), $LOAD_PATH].flatten
   end
 end
diff --git a/lib/puppet/util/backups.rb b/lib/puppet/util/backups.rb
index c01bdd400..cc7a997b8 100644
--- a/lib/puppet/util/backups.rb
+++ b/lib/puppet/util/backups.rb
@@ -1,87 +1,88 @@
 require 'find'
 require 'fileutils'
 module Puppet::Util::Backups
 
   # Deal with backups.
   def perform_backup(file = nil)
     # if they specifically don't want a backup, then just say
     # we're good
     return true unless self[:backup]
 
     # let the path be specified
     file ||= self[:path]
     return true unless FileTest.exists?(file)
 
     return(self.bucket ? perform_backup_with_bucket(file) : perform_backup_with_backuplocal(file, self[:backup]))
   end
 
   private
 
   def perform_backup_with_bucket(fileobj)
     file = (fileobj.class == String) ? fileobj : fileobj.name
     case File.stat(file).ftype
     when "directory"
       # we don't need to backup directories when recurse is on
       return true if self[:recurse]
       info "Recursively backing up to filebucket"
       Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
     when "file"; backup_file_with_filebucket(file)
     when "link";
     end
     true
   end
 
   def perform_backup_with_backuplocal(fileobj, backup)
     file = (fileobj.class == String) ? fileobj : fileobj.name
     newfile = file + backup
 
     remove_backup(newfile)
 
     begin
       bfile = file + backup
 
       # Ruby 1.8.1 requires the 'preserve' addition, but
       # later versions do not appear to require it.
       # N.B. cp_r works on both files and directories
       FileUtils.cp_r(file, bfile, :preserve => true)
       return true
     rescue => detail
       # since they said they want a backup, let's error out
       # if we couldn't make one
       self.fail "Could not back #{file} up: #{detail.message}"
     end
   end
 
   def remove_backup(newfile)
     if self.class.name == :file and self[:links] != :follow
       method = :lstat
     else
       method = :stat
     end
 
     begin
       stat = File.send(method, newfile)
     rescue Errno::ENOENT
       return
     end
 
     if stat.ftype == "directory"
       raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
     end
 
     info "Removing old backup of type #{stat.ftype}"
 
     begin
       File.unlink(newfile)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      self.fail "Could not remove old backup: #{detail}"
+      message = "Could not remove old backup: #{detail}"
+      self.log_exception(detail, message)
+      self.fail message
     end
   end
 
   def backup_file_with_filebucket(f)
     sum = self.bucket.backup(f)
     self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
     return sum
     end
 end
diff --git a/lib/puppet/util/docs.rb b/lib/puppet/util/docs.rb
index 0a7c9bce8..0e9277f97 100644
--- a/lib/puppet/util/docs.rb
+++ b/lib/puppet/util/docs.rb
@@ -1,123 +1,122 @@
 # Some simple methods for helping manage automatic documentation generation.
 module Puppet::Util::Docs
   # Specify the actual doc string.
   def desc(str)
     @doc = str
   end
 
   # Add a new autodoc block.  We have to define these as class methods,
   # rather than just sticking them in a hash, because otherwise they're
   # too difficult to do inheritance with.
   def dochook(name, &block)
     method = "dochook_#{name}"
 
     meta_def method, &block
   end
 
   attr_writer :doc
 
   # Generate the full doc string.
   def doc
     extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
       self.send(m)
     }.delete_if {|r| r.nil? }.join("  ")
 
     if @doc
       @doc + (extra.empty? ? '' : "\n\n" + extra)
     else
       extra
     end
   end
 
   # Build a table
   def doctable(headers, data)
     str = "\n\n"
 
     lengths = []
     # Figure out the longest field for all columns
     data.each do |name, values|
       [name, values].flatten.each_with_index do |value, i|
         lengths[i] ||= 0
         lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
       end
     end
 
     # The headers could also be longest
     headers.each_with_index do |value, i|
       lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
     end
 
     # Add the header names
     str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
 
     # And the header row
     str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
 
     # Now each data row
     data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
       str += [name, rows].flatten.zip(lengths).collect do |value, length|
         pad(value, length)
       end.join(" | ") + " |" + "\n"
     end
 
     str + "\n"
   end
 
   attr_reader :nodoc
   def nodoc?
     nodoc
   end
 
   # Pad a field with spaces
   def pad(value, length)
     value.to_s + (" " * (length - value.to_s.length))
   end
 
   HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
 
   def markdown_header(name, level)
     "#{HEADER_LEVELS[level]} #{name}\n\n"
   end
 
   def markdown_definitionlist(term, definition)
     lines = scrub(definition).split("\n")
     str = "#{term}\n: #{lines.shift}\n"
     lines.each do |line|
       str << "  " if line =~ /\S/
       str << "#{line}\n"
     end
     str << "\n"
   end
 
   # Handle the inline indentation in the docs.
   def scrub(text)
     # Stupid markdown
     #text = text.gsub("<%=", "&lt;%=")
     # For text with no carriage returns, there's nothing to do.
     return text if text !~ /\n/
     indent = nil
 
     # If we can match an indentation, then just remove that same level of
     # indent from every line.  However, ignore any indentation on the
     # first line, since that can be inconsistent.
     text = text.lstrip
     text.gsub!(/^([\t]+)/) { |s| " "*8*s.length; } # Expand leading tabs
     # Find first non-empty line after the first line:
     line2start = (text =~ /(\n?\s*\n)/)
     line2start += $1.length
     if (text[line2start..-1] =~ /^([ ]+)\S/) == 0
       indent = Regexp.quote($1)
       begin
         return text.gsub(/^#{indent}/,'')
       rescue => detail
-        puts detail.backtrace
-        puts detail
+        Puppet.log_exception(detail)
       end
     else
       return text
     end
 
   end
 
   module_function :scrub
 end
diff --git a/lib/puppet/util/execution.rb b/lib/puppet/util/execution.rb
index 2833ece25..b1435f15e 100644
--- a/lib/puppet/util/execution.rb
+++ b/lib/puppet/util/execution.rb
@@ -1,237 +1,235 @@
 module Puppet
 
   # A command failed to execute.
   require 'puppet/error'
   class ExecutionFailure < Puppet::Error
   end
 
 module Util::Execution
 
   # Execute the provided command in a pipe, yielding the pipe object.
   def self.execpipe(command, failonfail = true)
     if respond_to? :debug
       debug "Executing '#{command}'"
     else
       Puppet.debug "Executing '#{command}'"
     end
 
     command_str = command.respond_to?(:join) ? command.join('') : command
     output = open("| #{command_str} 2>&1") do |pipe|
       yield pipe
     end
 
     if failonfail
       unless $CHILD_STATUS == 0
         raise ExecutionFailure, output
       end
     end
 
     output
   end
 
   def self.execfail(command, exception)
     output = execute(command)
     return output
   rescue ExecutionFailure
     raise exception, output
   end
 
 
 
   # Execute the desired command, and return the status and output.
   # def execute(command, arguments)
   # [arguments] a Hash optionally containing any of the following keys:
   #   :failonfail (default true) -- if this value is set to true, then this method will raise an error if the
   #      command is not executed successfully.
   #   :uid (default nil) -- the user id of the user that the process should be run as
   #   :gid (default nil) -- the group id of the group that the process should be run as
   #   :combine (default true) -- sets whether or not to combine stdout/stderr in the output
   #   :stdinfile (default nil) -- sets a file that can be used for stdin. Passing a string for stdin is not currently
   #      supported.
   #   :squelch (default false) -- if true, ignore stdout / stderr completely
   #   :override_locale (default true) -- by default (and if this option is set to true), we will temporarily override
   #     the user/system locale to "C" (via environment variables LANG and LC_*) while we are executing the command.
   #     This ensures that the output of the command will be formatted consistently, making it predictable for parsing.
   #     Passing in a value of false for this option will allow the command to be executed using the user/system locale.
   #   :custom_environment (default {}) -- a hash of key/value pairs to set as environment variables for the duration
   #     of the command
   def self.execute(command, arguments = {})
 
     # specifying these here rather than in the method signature to allow callers to pass in a partial
     # set of overrides without affecting the default values for options that they don't pass in
     default_arguments = {
         :failonfail => true,
         :uid => nil,
         :gid => nil,
         :combine => true,
         :stdinfile => nil,
         :squelch => false,
         :override_locale => true,
         :custom_environment => {},
     }
 
     arguments = default_arguments.merge(arguments)
 
     if command.is_a?(Array)
       command = command.flatten.map(&:to_s)
       str = command.join(" ")
     elsif command.is_a?(String)
       str = command
     end
 
     if respond_to? :debug
       debug "Executing '#{str}'"
     else
       Puppet.debug "Executing '#{str}'"
     end
 
     null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
 
     stdin = File.open(arguments[:stdinfile] || null_file, 'r')
     stdout = arguments[:squelch] ? File.open(null_file, 'w') : Tempfile.new('puppet')
     stderr = arguments[:combine] ? stdout : File.open(null_file, 'w')
 
     exec_args = [command, arguments, stdin, stdout, stderr]
 
     if execution_stub = Puppet::Util::ExecutionStub.current_value
       return execution_stub.call(*exec_args)
     elsif Puppet.features.posix?
       child_pid = execute_posix(*exec_args)
       exit_status = Process.waitpid2(child_pid).last.exitstatus
     elsif Puppet.features.microsoft_windows?
       child_pid = execute_windows(*exec_args)
       exit_status = Process.waitpid2(child_pid).last
       # $CHILD_STATUS is not set when calling win32/process Process.create
       # and since it's read-only, we can't set it. But we can execute a
       # a shell that simply returns the desired exit status, which has the
       # desired effect.
       %x{#{ENV['COMSPEC']} /c exit #{exit_status}}
     end
 
     [stdin, stdout, stderr].each {|io| io.close rescue nil}
 
     # read output in if required
     unless arguments[:squelch]
       output = wait_for_output(stdout)
       Puppet.warning "Could not get output" unless output
     end
 
     if arguments[:failonfail] and exit_status != 0
       raise ExecutionFailure, "Execution of '#{str}' returned #{exit_status}: #{output}"
     end
 
     output
   end
 
 
 
   # Because some modules provide their own version of this method.
   class << self
     alias util_execute execute
   end
 
 
   # this is private method, see call to private_class_method after method definition
   def self.execute_posix(command, arguments, stdin, stdout, stderr)
     child_pid = Kernel.fork do
       # We can't just call Array(command), and rely on it returning
       # things like ['foo'], when passed ['foo'], because
       # Array(command) will call command.to_a internally, which when
       # given a string can end up doing Very Bad Things(TM), such as
       # turning "/tmp/foo;\r\n /bin/echo" into ["/tmp/foo;\r\n", " /bin/echo"]
       command = [command].flatten
       Process.setsid
       begin
         $stdin.reopen(stdin)
         $stdout.reopen(stdout)
         $stderr.reopen(stderr)
 
         # we are in a forked process, so we currently have access to all of the file descriptors
         # from the parent process... which, in this case, is bad because we don't want
         # to allow the user's command to have access to them.  Therefore, we'll close them off.
         # (assumes that there are only 256 file descriptors used)
         3.upto(256){|fd| IO::new(fd).close rescue nil}
 
         Puppet::Util::SUIDManager.change_group(arguments[:gid], true) if arguments[:gid]
         Puppet::Util::SUIDManager.change_user(arguments[:uid], true)  if arguments[:uid]
 
         # if the caller has requested that we override locale environment variables,
         if (arguments[:override_locale]) then
           # loop over them and clear them
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each { |name| ENV.delete(name) }
           # set LANG and LC_ALL to 'C' so that the command will have consistent, predictable output
           # it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
           # a forked process.
           ENV['LANG'] = 'C'
           ENV['LC_ALL'] = 'C'
         end
 
         # unset all of the user-related environment variables so that different methods of starting puppet
         # (automatic start during boot, via 'service', via /etc/init.d, etc.) won't have unexpected side
         # effects relating to user / home dir environment vars.
         # it's OK to manipulate these directly rather than, e.g., via "withenv", because we are in
         # a forked process.
         Puppet::Util::POSIX::USER_ENV_VARS.each { |name| ENV.delete(name) }
 
         arguments[:custom_environment] ||= {}
         Puppet::Util.withenv(arguments[:custom_environment]) do
           Kernel.exec(*command)
         end
       rescue => detail
-        puts detail.message
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not execute posix command: #{detail}"
+        Puppet.log_exception(detail, "Could not execute posix command: #{detail}")
         exit!(1)
       end
     end
     child_pid
   end
   private_class_method :execute_posix
 
 
   # this is private method, see call to private_class_method after method definition
   def self.execute_windows(command, arguments, stdin, stdout, stderr)
     command = command.map do |part|
       part.include?(' ') ? %Q["#{part.gsub(/"/, '\"')}"] : part
     end.join(" ") if command.is_a?(Array)
 
     arguments[:custom_environment] ||= {}
     process_info =
         Puppet::Util.withenv(arguments[:custom_environment]) do
           Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr} )
         end
     process_info.process_id
   end
   private_class_method :execute_windows
 
 
   # this is private method, see call to private_class_method after method definition
   def self.wait_for_output(stdout)
     # Make sure the file's actually been written.  This is basically a race
     # condition, and is probably a horrible way to handle it, but, well, oh
     # well.
     # (If this method were treated as private / inaccessible from outside of this file, we shouldn't have to worry
     #  about a race condition because all of the places that we call this from are preceded by a call to "waitpid2",
     #  meaning that the processes responsible for writing the file have completed before we get here.)
     2.times do |try|
       if File.exists?(stdout.path)
         output = stdout.open.read
 
         stdout.close(true)
 
         return output
       else
         time_to_sleep = try / 2.0
         Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
         sleep(time_to_sleep)
       end
     end
     nil
   end
   private_class_method :wait_for_output
 
 
 
 
 end
 end
diff --git a/lib/puppet/util/filetype.rb b/lib/puppet/util/filetype.rb
index f4d878b65..a5c0a481e 100755
--- a/lib/puppet/util/filetype.rb
+++ b/lib/puppet/util/filetype.rb
@@ -1,283 +1,285 @@
 # Basic classes for reading, writing, and emptying files.  Not much
 # to see here.
 
 require 'puppet/util/selinux'
 require 'fileutils'
 
 class Puppet::Util::FileType
   attr_accessor :loaded, :path, :synced
 
   include Puppet::Util::SELinux
 
   class << self
     attr_accessor :name
     include Puppet::Util::ClassGen
   end
 
   # Create a new filetype.
   def self.newfiletype(name, &block)
     @filetypes ||= {}
 
 
           klass = genclass(
         name,
       :block => block,
       :prefix => "FileType",
         
       :hash => @filetypes
     )
 
     # Rename the read and write methods, so that we're sure they
     # maintain the stats.
     klass.class_eval do
       # Rename the read method
       define_method(:real_read, instance_method(:read))
       define_method(:read) do
         begin
           val = real_read
           @loaded = Time.now
           if val
             return val.gsub(/# HEADER.*\n/,'')
           else
             return ""
           end
         rescue Puppet::Error => detail
           raise
         rescue => detail
-          puts detail.backtrace if Puppet[:trace]
-          raise Puppet::Error, "#{self.class} could not read #{@path}: #{detail}"
+          message = "#{self.class} could not read #{@path}: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       end
 
       # And then the write method
       define_method(:real_write, instance_method(:write))
       define_method(:write) do |text|
         begin
           val = real_write(text)
           @synced = Time.now
           return val
         rescue Puppet::Error => detail
           raise
         rescue => detail
-          puts detail.backtrace if Puppet[:debug]
-          raise Puppet::Error, "#{self.class} could not write #{@path}: #{detail}"
+          message = "#{self.class} could not write #{@path}: #{detail}"
+          Puppet.log_exception(detail, message)
+          raise Puppet::Error, message
         end
       end
     end
   end
 
   def self.filetype(type)
     @filetypes[type]
   end
 
   # Pick or create a filebucket to use.
   def bucket
     @bucket ||= Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
   end
 
   def initialize(path)
     raise ArgumentError.new("Path is nil") if path.nil?
     @path = path
   end
 
   # Operate on plain files.
   newfiletype(:flat) do
     # Back the file up before replacing it.
     def backup
       bucket.backup(@path) if File.exists?(@path)
     end
 
     # Read the file.
     def read
       if File.exist?(@path)
         File.read(@path)
       else
         return nil
       end
     end
 
     # Remove the file.
     def remove
       File.unlink(@path) if File.exist?(@path)
     end
 
     # Overwrite the file.
     def write(text)
       require "tempfile"
       tf = Tempfile.new("puppet")
       tf.print text; tf.flush
       FileUtils.cp(tf.path, @path)
       tf.close
       # If SELinux is present, we need to ensure the file has its expected context
       set_selinux_default_context(@path)
     end
   end
 
   # Operate on plain files.
   newfiletype(:ram) do
     @@tabs = {}
 
     def self.clear
       @@tabs.clear
     end
 
     def initialize(path)
       super
       @@tabs[@path] ||= ""
     end
 
     # Read the file.
     def read
       Puppet.info "Reading #{@path} from RAM"
       @@tabs[@path]
     end
 
     # Remove the file.
     def remove
       Puppet.info "Removing #{@path} from RAM"
       @@tabs[@path] = ""
     end
 
     # Overwrite the file.
     def write(text)
       Puppet.info "Writing #{@path} to RAM"
       @@tabs[@path] = text
     end
   end
 
   # Handle Linux-style cron tabs.
   newfiletype(:crontab) do
     def initialize(user)
       self.path = user
     end
 
     def path=(user)
       begin
         @uid = Puppet::Util.uid(user)
       rescue Puppet::Error => detail
         raise Puppet::Error, "Could not retrieve user #{user}"
       end
 
       # XXX We have to have the user name, not the uid, because some
       # systems *cough*linux*cough* require it that way
       @path = user
     end
 
     # Read a specific @path's cron tab.
     def read
       %x{#{cmdbase} -l 2>/dev/null}
     end
 
     # Remove a specific @path's cron tab.
     def remove
       if %w{Darwin FreeBSD}.include?(Facter.value("operatingsystem"))
         %x{/bin/echo yes | #{cmdbase} -r 2>/dev/null}
       else
         %x{#{cmdbase} -r 2>/dev/null}
       end
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
     def write(text)
       IO.popen("#{cmdbase()} -", "w") { |p|
         p.print text
       }
     end
 
     private
 
     # Only add the -u flag when the @path is different.  Fedora apparently
     # does not think I should be allowed to set the @path to my own user name
     def cmdbase
       cmd = nil
       if @uid == Puppet::Util::SUIDManager.uid || Facter.value(:operatingsystem) == "HP-UX"
         return "crontab"
       else
         return "crontab -u #{@path}"
       end
     end
   end
 
   # SunOS has completely different cron commands; this class implements
   # its versions.
   newfiletype(:suntab) do
     # Read a specific @path's cron tab.
     def read
         output = Puppet::Util::Execution.execute(%w{crontab -l}, :uid => @path)
         return "" if output.include?("can't open your crontab")
         raise Puppet::Error, "User #{@path} not authorized to use cron" if output.include?("you are not authorized to use cron")
         return output
     rescue => detail
         raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}"
     end
 
     # Remove a specific @path's cron tab.
     def remove
         Puppet::Util::Execution.execute(%w{crontab -r}, :uid => @path)
     rescue => detail
         raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}"
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
     def write(text)
       puts text
       require "tempfile"
       output_file = Tempfile.new("puppet")
       fh = output_file.open
       fh.print text
       fh.close
 
       # We have to chown the stupid file to the user.
       File.chown(Puppet::Util.uid(@path), nil, output_file.path)
 
       begin
         Puppet::Util::Execution.execute(["crontab", output_file.path], :uid => @path)
       rescue => detail
         raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}"
       end
       output_file.delete
     end
   end
 
   #  Support for AIX crontab with output different than suntab's crontab command.
   newfiletype(:aixtab) do
     # Read a specific @path's cron tab.
     def read
         output = Puppet::Util::Execution.execute(%w{crontab -l}, :uid => @path)
         raise Puppet::Error, "User #{@path} not authorized to use cron" if output.include?("You are not authorized to use the cron command")
         return output
     rescue => detail
         raise Puppet::Error, "Could not read crontab for #{@path}: #{detail}"
     end
 
     # Remove a specific @path's cron tab.
     def remove
         Puppet::Util::Execution.execute(%w{crontab -r}, :uid => @path)
     rescue => detail
         raise Puppet::Error, "Could not remove crontab for #{@path}: #{detail}"
     end
 
     # Overwrite a specific @path's cron tab; must be passed the @path name
     # and the text with which to create the cron tab.
     def write(text)
       require "tempfile"
       output_file = Tempfile.new("puppet")
       fh = output_file.open
       fh.print text
       fh.close
 
       # We have to chown the stupid file to the user.
       File.chown(Puppet::Util.uid(@path), nil, output_file.path)
 
       begin
         Puppet::Util::Execution.execute(["crontab", output_file.path], :uid => @path)
       rescue => detail
         raise Puppet::Error, "Could not write crontab for #{@path}: #{detail}"
       ensure
         output_file.delete
       end
     end
   end
 end
diff --git a/lib/puppet/util/log.rb b/lib/puppet/util/log.rb
index 67eaf645b..29326e9d8 100644
--- a/lib/puppet/util/log.rb
+++ b/lib/puppet/util/log.rb
@@ -1,269 +1,269 @@
 require 'puppet/util/tagging'
 require 'puppet/util/classgen'
 
 # Pass feedback to the user.  Log levels are modeled after syslog's, and it is
 # expected that that will be the most common log destination.  Supports
 # multiple destinations, one of which is a remote server.
 class Puppet::Util::Log
   include Puppet::Util
   extend Puppet::Util::ClassGen
   include Puppet::Util::Tagging
 
   @levels = [:debug,:info,:notice,:warning,:err,:alert,:emerg,:crit]
   @loglevel = 2
 
   @desttypes = {}
 
   # Create a new destination type.
   def self.newdesttype(name, options = {}, &block)
 
     dest = genclass(
       name,
       :parent     => Puppet::Util::Log::Destination,
       :prefix     => "Dest",
       :block      => block,
       :hash       => @desttypes,
       :attributes => options
     )
     dest.match(dest.name)
 
     dest
   end
 
   require 'puppet/util/log/destination'
   require 'puppet/util/log/destinations'
 
   @destinations = {}
 
   @queued = []
 
   class << self
     include Puppet::Util
     include Puppet::Util::ClassGen
 
     attr_reader :desttypes
   end
 
   # Reset log to basics.  Basically just flushes and closes files and
   # undefs other objects.
   def Log.close(destination)
     if @destinations.include?(destination)
       @destinations[destination].flush if @destinations[destination].respond_to?(:flush)
       @destinations[destination].close if @destinations[destination].respond_to?(:close)
       @destinations.delete(destination)
     end
   end
 
   def self.close_all
     destinations.keys.each { |dest|
       close(dest)
     }
     raise Puppet::DevError.new("Log.close_all failed to close #{@destinations.keys.inspect}") if !@destinations.empty?
   end
 
   # Flush any log destinations that support such operations.
   def Log.flush
     @destinations.each { |type, dest|
       dest.flush if dest.respond_to?(:flush)
     }
   end
 
   def Log.autoflush=(v)
     @destinations.each do |type, dest|
       dest.autoflush = v if dest.respond_to?(:autoflush=)
     end
   end
 
   # Create a new log message.  The primary role of this method is to
   # avoid creating log messages below the loglevel.
   def Log.create(hash)
     raise Puppet::DevError, "Logs require a level" unless hash.include?(:level)
     raise Puppet::DevError, "Invalid log level #{hash[:level]}" unless @levels.index(hash[:level])
     @levels.index(hash[:level]) >= @loglevel ? Puppet::Util::Log.new(hash) : nil
   end
 
   def Log.destinations
     @destinations
   end
 
   # Yield each valid level in turn
   def Log.eachlevel
     @levels.each { |level| yield level }
   end
 
   # Return the current log level.
   def Log.level
     @levels[@loglevel]
   end
 
   # Set the current log level.
   def Log.level=(level)
     level = level.intern unless level.is_a?(Symbol)
 
     raise Puppet::DevError, "Invalid loglevel #{level}" unless @levels.include?(level)
 
     @loglevel = @levels.index(level)
   end
 
   def Log.levels
     @levels.dup
   end
 
   # Create a new log destination.
   def Log.newdestination(dest)
     # Each destination can only occur once.
     if @destinations.find { |name, obj| obj.name == dest }
       return
     end
 
     name, type = @desttypes.find do |name, klass|
       klass.match?(dest)
     end
 
     if type.respond_to?(:suitable?) and not type.suitable?(dest)
       return
     end
 
     raise Puppet::DevError, "Unknown destination type #{dest}" unless type
 
     begin
       if type.instance_method(:initialize).arity == 1
         @destinations[dest] = type.new(dest)
       else
         @destinations[dest] = type.new
       end
       flushqueue
       @destinations[dest]
     rescue => detail
-      puts detail.backtrace if Puppet[:debug]
+      Puppet.log_exception(detail)
 
       # If this was our only destination, then add the console back in.
       newdestination(:console) if @destinations.empty? and (dest != :console and dest != "console")
     end
   end
 
   # Route the actual message. FIXME There are lots of things this method
   # should do, like caching and a bit more.  It's worth noting that there's
   # a potential for a loop here, if the machine somehow gets the destination set as
   # itself.
   def Log.newmessage(msg)
     return if @levels.index(msg.level) < @loglevel
 
     queuemessage(msg) if @destinations.length == 0
 
     @destinations.each do |name, dest|
       threadlock(dest) do
         dest.handle(msg)
       end
     end
   end
 
   def Log.queuemessage(msg)
     @queued.push(msg)
   end
 
   def Log.flushqueue
     return unless @destinations.size >= 1
     @queued.each do |msg|
       Log.newmessage(msg)
     end
     @queued.clear
   end
 
   def Log.sendlevel?(level)
     @levels.index(level) >= @loglevel
   end
 
   # Reopen all of our logs.
   def Log.reopen
     Puppet.notice "Reopening log files"
     types = @destinations.keys
     @destinations.each { |type, dest|
       dest.close if dest.respond_to?(:close)
     }
     @destinations.clear
     # We need to make sure we always end up with some kind of destination
     begin
       types.each { |type|
         Log.newdestination(type)
       }
     rescue => detail
       if @destinations.empty?
         Log.newdestination(:syslog)
         Puppet.err detail.to_s
       end
     end
   end
 
   # Is the passed level a valid log level?
   def self.validlevel?(level)
     @levels.include?(level)
   end
 
   attr_accessor :time, :remote, :file, :line, :source
   attr_reader :level, :message
 
   def initialize(args)
     self.level = args[:level]
     self.message = args[:message]
     self.source = args[:source] || "Puppet"
 
     @time = Time.now
 
     if tags = args[:tags]
       tags.each { |t| self.tag(t) }
     end
 
     [:file, :line].each do |attr|
       next unless value = args[attr]
       send(attr.to_s + "=", value)
     end
 
     Log.newmessage(self)
   end
 
   def message=(msg)
     raise ArgumentError, "Puppet::Util::Log requires a message" unless msg
     @message = msg.to_s
   end
 
   def level=(level)
     raise ArgumentError, "Puppet::Util::Log requires a log level" unless level
     @level = level.to_sym
     raise ArgumentError, "Invalid log level #{@level}" unless self.class.validlevel?(@level)
 
     # Tag myself with my log level
     tag(level)
   end
 
   # If they pass a source in to us, we make sure it is a string, and
   # we retrieve any tags we can.
   def source=(source)
     if source.respond_to?(:source_descriptors)
       descriptors = source.source_descriptors
       @source = descriptors[:path]
 
       descriptors[:tags].each { |t| tag(t) }
 
       [:file, :line].each do |param|
         next unless descriptors[param]
         send(param.to_s + "=", descriptors[param])
       end
     else
       @source = source.to_s
     end
   end
 
   def to_report
     "#{time} #{source} (#{level}): #{to_s}"
   end
 
   def to_s
     message
   end
 end
 
 # This is for backward compatibility from when we changed the constant to Puppet::Util::Log
 # because the reports include the constant name.  Apparently the alias was created in
 # March 2007, should could probably be removed soon.
 Puppet::Log = Puppet::Util::Log
diff --git a/lib/puppet/util/log/destinations.rb b/lib/puppet/util/log/destinations.rb
index 0ba036cef..fb43db8cd 100644
--- a/lib/puppet/util/log/destinations.rb
+++ b/lib/puppet/util/log/destinations.rb
@@ -1,239 +1,238 @@
 Puppet::Util::Log.newdesttype :syslog do
   def self.suitable?(obj)
     Puppet.features.syslog?
   end
 
   def close
     Syslog.close
   end
 
   def initialize
     Syslog.close if Syslog.opened?
     name = Puppet[:name]
     name = "puppet-#{name}" unless name =~ /puppet/
 
     options = Syslog::LOG_PID | Syslog::LOG_NDELAY
 
     # XXX This should really be configurable.
     str = Puppet[:syslogfacility]
     begin
       facility = Syslog.const_get("LOG_#{str.upcase}")
     rescue NameError
       raise Puppet::Error, "Invalid syslog facility #{str}"
     end
 
     @syslog = Syslog.open(name, options, facility)
   end
 
   def handle(msg)
     # XXX Syslog currently has a bug that makes it so you
     # cannot log a message with a '%' in it.  So, we get rid
     # of them.
     if msg.source == "Puppet"
       @syslog.send(msg.level, msg.to_s.gsub("%", '%%'))
     else
       @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
           msg.to_s.gsub("%", '%%')
         ]
       )
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :file do
   require 'fileutils'
 
   def self.match?(obj)
     Puppet::Util.absolute_path?(obj)
   end
 
   def close
     if defined?(@file)
       @file.close
       @file = nil
     end
   end
 
   def flush
     @file.flush if defined?(@file)
   end
 
   attr_accessor :autoflush
 
   def initialize(path)
     @name = path
     # first make sure the directory exists
     # We can't just use 'Config.use' here, because they've
     # specified a "special" destination.
     unless FileTest.exist?(File.dirname(path))
       FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
       Puppet.info "Creating log directory #{File.dirname(path)}"
     end
 
     # create the log file, if it doesn't already exist
     file = File.open(path, File::WRONLY|File::CREAT|File::APPEND)
 
     @file = file
 
     @autoflush = Puppet[:autoflush]
   end
 
   def handle(msg)
     @file.puts("#{msg.time} #{msg.source} (#{msg.level}): #{msg}")
 
     @file.flush if @autoflush
   end
 end
 
 Puppet::Util::Log.newdesttype :console do
 
 
   RED     = {:console => "", :html => "FFA0A0"}
   GREEN   = {:console => "", :html => "00CD00"}
   YELLOW  = {:console => "", :html => "FFFF60"}
   BLUE    = {:console => "", :html => "80A0FF"}
   PURPLE  = {:console => "", :html => "FFA500"}
   CYAN    = {:console => "", :html => "40FFFF"}
   WHITE   = {:console => "", :html => "FFFFFF"}
   HRED    = {:console => "", :html => "FFA0A0"}
   HGREEN  = {:console => "", :html => "00CD00"}
   HYELLOW = {:console => "", :html => "FFFF60"}
   HBLUE   = {:console => "", :html => "80A0FF"}
   HPURPLE = {:console => "", :html => "FFA500"}
   HCYAN   = {:console => "", :html => "40FFFF"}
   HWHITE  = {:console => "", :html => "FFFFFF"}
   RESET   = {:console => "",    :html => ""      }
 
   Colormap = {
     :debug => WHITE,
     :info => GREEN,
     :notice => CYAN,
     :warning => YELLOW,
     :err => HPURPLE,
     :alert => RED,
     :emerg => HRED,
     :crit => HRED
   }
 
   def colorize(level, str)
     case Puppet[:color]
     when true, :ansi, "ansi", "yes"; console_color(level, str)
     when :html, "html"; html_color(level, str)
     else
       str
     end
   end
 
   def console_color(level, str)
     Colormap[level][:console] + str + RESET[:console]
   end
 
   def html_color(level, str)
     %{<span style="color: %s">%s</span>} % [Colormap[level][:html], str]
   end
 
   def initialize
     # Flush output immediately.
     $stdout.sync = true
   end
 
   def handle(msg)
     if msg.source == "Puppet"
       puts colorize(msg.level, "#{msg.level}: #{msg}")
     else
       puts colorize(msg.level, "#{msg.level}: #{msg.source}: #{msg}")
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :host do
   def initialize(host)
     Puppet.info "Treating #{host} as a hostname"
     args = {}
     if host =~ /:(\d+)/
       args[:Port] = $1
       args[:Server] = host.sub(/:\d+/, '')
     else
       args[:Server] = host
     end
 
     @name = host
 
     @driver = Puppet::Network::Client::LogClient.new(args)
   end
 
   def handle(msg)
     unless msg.is_a?(String) or msg.remote
       @hostname ||= Facter["hostname"].value
       unless defined?(@domain)
         @domain = Facter["domain"].value
         @hostname += ".#{@domain}" if @domain
       end
       if Puppet::Util.absolute_path?(msg.source)
         msg.source = @hostname + ":#{msg.source}"
       elsif msg.source == "Puppet"
         msg.source = @hostname + " #{msg.source}"
       else
         msg.source = @hostname + " #{msg.source}"
       end
       begin
         #puts "would have sent #{msg}"
         #puts "would have sent %s" %
         #    CGI.escape(YAML.dump(msg))
         begin
           tmp = CGI.escape(YAML.dump(msg))
         rescue => detail
           puts "Could not dump: #{detail}"
           return
         end
         # Add the hostname to the source
         @driver.addlog(tmp)
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err detail
+        Puppet.log_exception(detail)
         Puppet::Util::Log.close(self)
       end
     end
   end
 end
 
 # Log to a transaction report.
 Puppet::Util::Log.newdesttype :report do
   attr_reader :report
 
   match "Puppet::Transaction::Report"
 
   def initialize(report)
     @report = report
   end
 
   def handle(msg)
     @report << msg
   end
 end
 
 # Log to an array, just for testing.
 module Puppet::Test
   class LogCollector
     def initialize(logs)
       @logs = logs
     end
 
     def <<(value)
       @logs << value
     end
   end
 end
 
 Puppet::Util::Log.newdesttype :array do
   match "Puppet::Test::LogCollector"
 
   def initialize(messages)
     @messages = messages
   end
 
   def handle(msg)
     @messages << msg
   end
 end
 
diff --git a/lib/puppet/util/logging.rb b/lib/puppet/util/logging.rb
index eea321bd9..929310d23 100644
--- a/lib/puppet/util/logging.rb
+++ b/lib/puppet/util/logging.rb
@@ -1,127 +1,126 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 
 module Puppet::Util::Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
   end
 
   # Create a method for each log level.
   Puppet::Util::Log.eachlevel do |level|
     define_method(level) do |args|
       args = args.join(" ") if args.is_a?(Array)
       send_log(level, args)
     end
   end
 
-  # Log an exception.  Will also log the backtrace if Puppet[:trace] is set.
+  # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
   # Parameters:
   # [exception] an Exception to log
-  # [options] an optional Hash containing some configuration options about how to log the exception.
-  #     Available options include:
-  #     * :message => an optional String overriding the message to be logged; by default, we log Exception.message.
-  #             If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
-  #             wish to log a message at all; in this case it is likely that you are only calling this method in order
-  #             to take advantage of the backtrace logging.
-  #     * :level => the log level to log the message at.  Defaults to :err.
-  def log_exception(exception, options = {})
-
-    default_options = {
-      :message => :default,
-      :level => :err,
-    }
-
-    options = default_options.merge(options)
-
-    case options[:message]
+  # [message] an optional String overriding the message to be logged; by default, we log Exception.message.
+  #    If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
+  #    wish to log a message at all; in this case it is likely that you are only calling this method in order
+  #    to take advantage of the backtrace logging.
+  def log_exception(exception, message = :default)
+
+    case message
       when :default
-        send(options[:level], exception.message)
+        err(exception.message)
       when nil
         # don't log anything if they passed a nil; they are just calling for the optional backtrace logging
       else
-        send(options[:level], options[:message])
+        err(message)
     end
 
-    send(options[:level], exception.backtrace) if Puppet[:trace] && exception.backtrace
+    err(exception.backtrace) if Puppet[:trace] && exception.backtrace
   end
 
   class DeprecationWarning < Exception; end
 
+  # Log a warning indicating that the code path is deprecated.  Note that this method keeps track of the
+  # offending lines of code that triggered the deprecation warning, and will only log a warning once per
+  # offending line of code.  It will also stop logging deprecation warnings altogether after 100 unique
+  # deprecation warnings have been logged.
+  # Parameters:
+  # [message] The message to log (logs via )
   def deprecation_warning(message)
     $deprecation_warnings ||= {}
     if $deprecation_warnings.length < 100 then
       offender = get_deprecation_offender()
       if (! $deprecation_warnings.has_key?(offender)) then
         $deprecation_warnings[offender] = message
-        log_exception(DeprecationWarning.new(message), :level => :warning)
+        warning("#{message}\n   (at #{offender})")
       end
     end
   end
 
   def get_deprecation_offender()
     # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
     # order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
     #
     # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
     #  the deprecated method
     caller()[2]
   end
 
   def clear_deprecation_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
+  # TODO: determine whether there might be a potential use for adding a puppet configuration option that would
+  # enable this deprecation logging.
+
   # utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
   # code.
   # Parameters:
   # [deprecations_file] relative or absolute path of a file to log the deprecations to
   # [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
   def log_deprecations_to_file(deprecations_file, pattern = nil)
     # this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
     # list of deprecation warnings being cleared out.  We don't want to keep logging the same offenders over and over,
     # so, we need to keep track of what we've logged.
     #
     # It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
     # find the same offender, and we'd end up logging it again.
     $logged_deprecation_warnings ||= {}
 
     File.open(deprecations_file, "a") do |f|
       if ($deprecation_warnings) then
         $deprecation_warnings.each do |offender, message|
           if (! $logged_deprecation_warnings.has_key?(offender)) then
             $logged_deprecation_warnings[offender] = true
             if ((pattern.nil?) || (message =~ pattern)) then
               f.puts(message)
               f.puts(offender)
               f.puts()
             end
           end
         end
       end
     end
   end
 
   private
 
   def is_resource?
     defined?(Puppet::Type) && is_a?(Puppet::Type)
   end
 
   def is_resource_parameter?
     defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
   end
 
   def log_metadata
     [:file, :line, :tags].inject({}) do |result, attr|
       result[attr] = send(attr) if respond_to?(attr)
       result
     end
   end
 
   def log_source
     # We need to guard the existence of the constants, since this module is used by the base Puppet module.
     (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
     to_s
   end
 end
diff --git a/lib/puppet/util/pidlock.rb b/lib/puppet/util/pidlock.rb
index 9eb1bd26c..6db0ae3db 100644
--- a/lib/puppet/util/pidlock.rb
+++ b/lib/puppet/util/pidlock.rb
@@ -1,68 +1,67 @@
 require 'fileutils'
 require 'puppet/util/anonymous_filelock'
 
 class Puppet::Util::Pidlock < Puppet::Util::AnonymousFilelock
 
   def locked?
     clear_if_stale
     File.exists? @lockfile
   end
 
   def mine?
     Process.pid == lock_pid
   end
 
   def anonymous?
     false
   end
 
   def lock
     return mine? if locked?
 
     File.open(@lockfile, "w") { |fd| fd.write(Process.pid) }
     true
   end
 
   def unlock(opts = {})
     if mine?
       begin
         File.unlink(@lockfile)
       rescue Errno::ENOENT
         # Someone deleted it for us ...and so we do nothing.  No point whining
         # about a problem that the user can't actually do anything about.
       rescue SystemCallError => e
         # This one is a real failure though.  No idea what went wrong, but it
         # is most likely "read only file(system)" or wrong permissions or
         # something like that.
-        Puppet.err "Could not remove PID file #{@lockfile}: #{e}"
-        puts e.backtrace if Puppet[:trace]
+        Puppet.log_exception(e, "Could not remove PID file #{@lockfile}: #{e}")
       end
       true
     else
       false
     end
   end
 
   def lock_pid
     if File.exists? @lockfile
       File.read(@lockfile).to_i
     else
       nil
     end
   end
 
   private
   def clear_if_stale
     return if lock_pid.nil?
 
     errors = [Errno::ESRCH]
     # Process::Error can only happen, and is only defined, on Windows
     errors << Process::Error if defined? Process::Error
 
     begin
       Process.kill(0, lock_pid)
     rescue *errors
       File.unlink(@lockfile)
     end
   end
 end
diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb
index 7870dee65..fa99a13dd 100644
--- a/lib/puppet/util/settings.rb
+++ b/lib/puppet/util/settings.rb
@@ -1,934 +1,932 @@
 require 'puppet'
 require 'sync'
 require 'getoptlong'
 require 'puppet/external/event-loop'
 require 'puppet/util/loadedfile'
 
 # The class for handling configuration files.
 class Puppet::Util::Settings
   include Enumerable
 
   require 'puppet/util/settings/setting'
   require 'puppet/util/settings/file_setting'
   require 'puppet/util/settings/boolean_setting'
 
   attr_accessor :file
   attr_reader :timer
 
   ReadOnly = [:run_mode, :name]
 
   # Retrieve a config value
   def [](param)
     value(param)
   end
 
   # Set a config value.  This doesn't set the defaults, it sets the value itself.
   def []=(param, value)
     set_value(param, value, :memory)
   end
 
   # Generate the list of valid arguments, in a format that GetoptLong can
   # understand, and add them to the passed option list.
   def addargs(options)
     # Add all of the config parameters as valid options.
     self.each { |name, setting|
       setting.getopt_args.each { |args| options << args }
     }
 
     options
   end
 
   # Generate the list of valid arguments, in a format that OptionParser can
   # understand, and add them to the passed option list.
   def optparse_addargs(options)
     # Add all of the config parameters as valid options.
     self.each { |name, setting|
       options << setting.optparse_args
     }
 
     options
   end
 
   # Is our parameter a boolean parameter?
   def boolean?(param)
     param = param.to_sym
     !!(@config.include?(param) and @config[param].kind_of? BooleanSetting)
   end
 
   # Remove all set values, potentially skipping cli values.
   def clear(exceptcli = false)
     @sync.synchronize do
       unsafe_clear(exceptcli)
     end
   end
 
   # Remove all set values, potentially skipping cli values.
   def unsafe_clear(exceptcli = false)
     @values.each do |name, values|
       @values.delete(name) unless exceptcli and name == :cli
     end
 
     # Don't clear the 'used' in this case, since it's a config file reparse,
     # and we want to retain this info.
     @used = [] unless exceptcli
 
     @cache.clear
   end
 
   # This is mostly just used for testing.
   def clearused
     @cache.clear
     @used = []
   end
 
   # Do variable interpolation on the value.
   def convert(value, environment = nil)
     return value unless value
     return value unless value.is_a? String
     newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
       varname = $2 || $1
       if varname == "environment" and environment
         environment
       elsif pval = self.value(varname, environment)
         pval
       else
         raise Puppet::DevError, "Could not find value for #{value}"
       end
     end
 
     newval
   end
 
   # Return a value's description.
   def description(name)
     if obj = @config[name.to_sym]
       obj.desc
     else
       nil
     end
   end
 
   def each
     @config.each { |name, object|
       yield name, object
     }
   end
 
   # Iterate over each section name.
   def eachsection
     yielded = []
     @config.each do |name, object|
       section = object.section
       unless yielded.include? section
         yield section
         yielded << section
       end
     end
   end
 
   # Return an object by name.
   def setting(param)
     param = param.to_sym
     @config[param]
   end
 
   # Handle a command-line argument.
   def handlearg(opt, value = nil)
     @cache.clear
     value &&= munge_value(value)
     str = opt.sub(/^--/,'')
 
     bool = true
     newstr = str.sub(/^no-/, '')
     if newstr != str
       str = newstr
       bool = false
     end
     str = str.intern
 
     if @config[str].is_a?(Puppet::Util::Settings::BooleanSetting)
       if value == "" or value.nil?
         value = bool
       end
     end
 
     set_value(str, value, :cli)
   end
 
   def include?(name)
     name = name.intern if name.is_a? String
     @config.include?(name)
   end
 
   # check to see if a short name is already defined
   def shortinclude?(short)
     short = short.intern if name.is_a? String
     @shortnames.include?(short)
   end
 
   # Create a new collection of config settings.
   def initialize
     @config = {}
     @shortnames = {}
 
     @created = []
     @searchpath = nil
 
     # Mutex-like thing to protect @values
     @sync = Sync.new
 
     # Keep track of set values.
     @values = Hash.new { |hash, key| hash[key] = {} }
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
   end
 
   # NOTE: ACS ahh the util classes. . .sigh
   # as part of a fix for 1183, I pulled the logic for the following 5 methods out of the executables and puppet.rb
   # They probably deserve their own class, but I don't want to do that until I can refactor environments
   # its a little better than where they were
 
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
     env = value(:environment)
     val = value(:configprint)
     if val == "all"
       hash = {}
       each do |name, obj|
         val = value(name,env)
         val = val.inspect if val == ""
         hash[name] = val
       end
       hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
         puts "#{name} = #{val}"
       end
     else
       val.split(/\s*,\s*/).sort.each do |v|
         if include?(v)
           #if there is only one value, just print it for back compatibility
           if v == val
             puts value(val,env)
             break
           end
           puts "#{v} = #{value(v,env)}"
         else
           puts "invalid parameter: #{v}"
           return false
         end
       end
     end
     true
   end
 
   def generate_config
     puts to_config
     true
   end
 
   def generate_manifest
     puts to_manifest
     true
   end
 
   def print_configs
     return print_config_options if value(:configprint) != ""
     return generate_config if value(:genconfig)
     generate_manifest if value(:genmanifest)
   end
 
   def print_configs?
     (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
   end
 
   # Return a given object's file metadata.
   def metadata(param)
     if obj = @config[param.to_sym] and obj.is_a?(FileSetting)
       return [:owner, :group, :mode].inject({}) do |meta, p|
         if v = obj.send(p)
           meta[p] = v
         end
         meta
       end
     else
       nil
     end
   end
 
   # Make a directory with the appropriate user, group, and mode
   def mkdir(default)
     obj = get_config_file_default(default)
 
     Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
       mode = obj.mode || 0750
       Dir.mkdir(obj.value, mode)
     end
   end
 
   # Figure out the section name for the run_mode.
   def run_mode
     Puppet.run_mode.name
   end
 
   # Return all of the parameters associated with a given section.
   def params(section = nil)
     if section
       section = section.intern if section.is_a? String
       @config.find_all { |name, obj|
         obj.section == section
       }.collect { |name, obj|
         name
       }
     else
       @config.keys
     end
   end
 
   # Parse the configuration file.  Just provides
   # thread safety.
   def parse
     raise "No :config setting defined; cannot parse unknown config file" unless self[:config]
 
     @sync.synchronize do
       unsafe_parse(self[:config])
     end
 
     # Create a timer so that this file will get checked automatically
     # and reparsed if necessary.
     set_filetimeout_timer
   end
 
   # Unsafely parse the file -- this isn't thread-safe and causes plenty of problems if used directly.
   def unsafe_parse(file)
     return unless FileTest.exist?(file)
     begin
       data = parse_file(file)
-    rescue => details
-      puts details.backtrace if Puppet[:trace]
-      Puppet.err "Could not parse #{file}: #{details}"
+    rescue => detail
+      Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
       return
     end
 
     unsafe_clear(true)
 
     metas = {}
     data.each do |area, values|
       metas[area] = values.delete(:_meta)
       values.each do |key,value|
         set_value(key, value, area, :dont_trigger_handles => true, :ignore_bad_settings => true )
       end
     end
 
     # Determine our environment, if we have one.
     if @config[:environment]
       env = self.value(:environment).to_sym
     else
       env = "none"
     end
 
     # Call any hooks we should be calling.
     settings_with_hooks.each do |setting|
       each_source(env) do |source|
         if value = @values[source][setting.name]
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           setting.handle(self.value(setting.name, env))
           break
         end
       end
     end
 
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     searchpath.reverse.each do |source|
       source = run_mode if source == :run_mode
       source = @name if (@name && source == :name)
       if meta = metas[source]
         set_metadata(meta)
       end
     end
   end
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
   def newsetting(hash)
     klass = nil
     hash[:section] = hash[:section].to_sym if hash[:section]
     if type = hash[:type]
       unless klass = {:setting => Setting, :file => FileSetting, :boolean => BooleanSetting}[type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
     else
       case hash[:default]
       when true, false, "true", "false"
         klass = BooleanSetting
       when /^\$\w+\//, /^\//, /^\w:\//
         klass = FileSetting
       when String, Integer, Float # nothing
         klass = Setting
       else
         raise ArgumentError, "Invalid value '#{hash[:default].inspect}' for #{hash[:name]}"
       end
     end
     hash[:settings] = self
     setting = klass.new(hash)
 
     setting
   end
 
   # This has to be private, because it doesn't add the settings to @config
   private :newsetting
 
   # Iterate across all of the objects in a given section.
   def persection(section)
     section = section.to_sym
     self.each { |name, obj|
       if obj.section == section
         yield obj
       end
     }
   end
 
   def file
     return @file if @file
     if path = self[:config] and FileTest.exist?(path)
       @file = Puppet::Util::LoadedFile.new(path)
     end
   end
 
   # Reparse our config file, if necessary.
   def reparse
     if file and file.changed?
       Puppet.notice "Reparsing #{file.file}"
       parse
       reuse
     end
   end
 
   def reuse
     return unless defined?(@used)
     @sync.synchronize do # yay, thread-safe
       new = @used
       @used = []
       self.use(*new)
     end
   end
 
   # The order in which to search for values.
   def searchpath(environment = nil)
     if environment
       [:cli, :memory, environment, :run_mode, :main, :mutable_defaults]
     else
       [:cli, :memory, :run_mode, :main, :mutable_defaults]
     end
   end
 
   # Get a list of objects per section
   def sectionlist
     sectionlist = []
     self.each { |name, obj|
       section = obj.section || "puppet"
       sections[section] ||= []
       sectionlist << section unless sectionlist.include?(section)
       sections[section] << obj
     }
 
     return sectionlist, sections
   end
 
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
     return @service_user_available = false unless user_name = self[:user]
 
     user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
     @service_user_available = user.exists?
   end
 
   def legacy_to_mode(type, param)
     if not defined?(@app_names)
       require 'puppet/util/command_line'
       command_line = Puppet::Util::CommandLine.new
       @app_names = Puppet::Util::CommandLine::LegacyName.inject({}) do |hash, pair|
         app, legacy = pair
         command_line.require_application app
         hash[legacy.to_sym] = Puppet::Application.find(app).run_mode.name
         hash
       end
     end
     if new_type = @app_names[type]
       Puppet.deprecation_warning "You have configuration parameter $#{param} specified in [#{type}], which is a deprecated section. I'm assuming you meant [#{new_type}]"
       return new_type
     end
     type
   end
 
   def set_value(param, value, type, options = {})
     param = param.to_sym
     unless setting = @config[param]
       if options[:ignore_bad_settings]
         return
       else
         raise ArgumentError,
           "Attempt to assign a value to unknown configuration parameter #{param.inspect}"
       end
     end
     value = setting.munge(value) if setting.respond_to?(:munge)
     setting.handle(value) if setting.respond_to?(:handle) and not options[:dont_trigger_handles]
     if ReadOnly.include? param and type != :mutable_defaults
       raise ArgumentError,
         "You're attempting to set configuration parameter $#{param}, which is read-only."
     end
     type = legacy_to_mode(type, param)
     @sync.synchronize do # yay, thread-safe
       # Allow later inspection to determine if the setting was set on the
       # command line, or through some other code path.  Used for the
       # `dns_alt_names` option during cert generate. --daniel 2011-10-18
       setting.setbycli = true if type == :cli
 
       @values[type][param] = value
       @cache.clear
 
       clearused
 
       # Clear the list of environments, because they cache, at least, the module path.
       # We *could* preferentially just clear them if the modulepath is changed,
       # but we don't really know if, say, the vardir is changed and the modulepath
       # is defined relative to it. We need the defined?(stuff) because of loading
       # order issues.
       Puppet::Node::Environment.clear if defined?(Puppet::Node) and defined?(Puppet::Node::Environment)
     end
 
     value
   end
 
   # Set a bunch of defaults in a given section.  The sections are actually pretty
   # pointless, but they help break things up a bit, anyway.
   def setdefaults(section, defs)
     section = section.to_sym
     call = []
     defs.each { |name, hash|
       if hash.is_a? Array
         unless hash.length == 2
           raise ArgumentError, "Defaults specified as an array must contain only the default value and the decription"
         end
         tmp = hash
         hash = {}
         [:default, :desc].zip(tmp).each { |p,v| hash[p] = v }
       end
       name = name.to_sym
       hash[:name] = name
       hash[:section] = section
       raise ArgumentError, "Parameter #{name} is already defined" if @config.include?(name)
       tryconfig = newsetting(hash)
       if short = tryconfig.short
         if other = @shortnames[short]
           raise ArgumentError, "Parameter #{other.name} is already using short name '#{short}'"
         end
         @shortnames[short] = tryconfig
       end
       @config[name] = tryconfig
 
       # Collect the settings that need to have their hooks called immediately.
       # We have to collect them so that we can be sure we're fully initialized before
       # the hook is called.
       call << tryconfig if tryconfig.call_on_define
     }
 
     call.each { |setting| setting.handle(self.value(setting.name)) }
   end
 
   # Create a timer to check whether the file should be reparsed.
   def set_filetimeout_timer
     return unless timeout = self[:filetimeout] and timeout = Integer(timeout) and timeout > 0
     timer = EventLoop::Timer.new(:interval => timeout, :tolerance => 1, :start? => true) { self.reparse }
   end
 
   # Convert the settings we manage into a catalog full of resources that model those settings.
   def to_catalog(*sections)
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings")
 
     @config.values.find_all { |value| value.is_a?(FileSetting) }.each do |file|
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
       next if catalog.resource(resource.ref)
 
       catalog.add_resource(resource)
     end
 
     add_user_resources(catalog, sections)
 
     catalog
   end
 
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet[:name]}.  Note that this file
 is likely to have unused configuration parameters in it; any parameter that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
 if @config.include?(:run_mode)
   str += "[#{self[:run_mode]}]\n"
     end
     eachsection do |section|
       persection(section) do |obj|
         str += obj.to_config + "\n" unless ReadOnly.include? obj.name or obj.name == :genconfig
       end
     end
 
     return str
   end
 
   # Convert to a parseable manifest
   def to_manifest
     catalog = to_catalog
     catalog.resource_refs.collect do |ref|
       catalog.resource(ref).to_manifest
     end.join("\n\n")
   end
 
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
     sections = sections.collect { |s| s.to_sym }
     @sync.synchronize do # yay, thread-safe
       sections = sections.reject { |s| @used.include?(s) }
 
       return if sections.empty?
 
       begin
         catalog = to_catalog(*sections).to_ral
       rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}"
+        Puppet.log_exception(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
 
         # We need some way to get rid of any resources created during the catalog creation
         # but not cleaned up.
         return
       end
 
       catalog.host_config = false
       catalog.apply do |transaction|
         if transaction.any_failed?
           report = transaction.report
           failures = report.logs.find_all { |log| log.level == :err }
           raise "Got #{failures.length} failure(s) while initializing: #{failures.collect { |l| l.to_s }.join("; ")}"
         end
       end
 
       sections.each { |s| @used << s }
       @used.uniq!
     end
   end
 
   def valid?(param)
     param = param.to_sym
     @config.has_key?(param)
   end
 
   def uninterpolated_value(param, environment = nil)
     param = param.to_sym
     environment &&= environment.to_sym
 
     # See if we can find it within our searchable list of values
     val = catch :foundval do
       each_source(environment) do |source|
         # Look for the value.  We have to test the hash for whether
         # it exists, because the value might be false.
         @sync.synchronize do
           throw :foundval, @values[source][param] if @values[source].include?(param)
         end
       end
       throw :foundval, nil
     end
 
     # If we didn't get a value, use the default
     val = @config[param].default if val.nil?
 
     val
   end
 
   # Find the correct value using our search path.  Optionally accept an environment
   # in which to search before the other configuration sections.
   def value(param, environment = nil)
     param = param.to_sym
     environment &&= environment.to_sym
 
     # Short circuit to nil for undefined parameters.
     return nil unless @config.include?(param)
 
     # Yay, recursion.
     #self.reparse unless [:config, :filetimeout].include?(param)
 
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
     if cached = @cache[environment||"none"][param]
       return cached
     end
 
     val = uninterpolated_value(param, environment)
 
     if param == :code
       # if we interpolate code, all hell breaks loose.
       return val
     end
 
     # Convert it if necessary
     val = convert(val, environment)
 
     # And cache it
     @cache[environment||"none"][param] = val
     val
   end
 
   # Open a file with the appropriate user, group, and mode
   def write(default, *args, &bloc)
     obj = get_config_file_default(default)
     writesub(default, value(obj.name), *args, &bloc)
   end
 
   # Open a non-default file under a default dir with the appropriate user,
   # group, and mode
   def writesub(default, file, *args, &bloc)
     obj = get_config_file_default(default)
     chown = nil
     if Puppet.features.root?
       chown = [obj.owner, obj.group]
     else
       chown = [nil, nil]
     end
 
     Puppet::Util::SUIDManager.asuser(*chown) do
       mode = obj.mode ? obj.mode.to_i : 0640
       args << "w" if args.empty?
 
       args << mode
 
       # Update the umask to make non-executable files
       Puppet::Util.withumask(File.umask ^ 0111) do
         File.open(file, *args) do |file|
           yield file
         end
       end
     end
   end
 
   def readwritelock(default, *args, &bloc)
     file = value(get_config_file_default(default).name)
     tmpfile = file + ".tmp"
     sync = Sync.new
     raise Puppet::DevError, "Cannot create #{file}; directory #{File.dirname(file)} does not exist" unless FileTest.directory?(File.dirname(tmpfile))
 
     sync.synchronize(Sync::EX) do
       File.open(file, ::File::CREAT|::File::RDWR, 0600) do |rf|
         rf.lock_exclusive do
           if File.exist?(tmpfile)
             raise Puppet::Error, ".tmp file already exists for #{file}; Aborting locked write. Check the .tmp file and delete if appropriate"
           end
 
           # If there's a failure, remove our tmpfile
           begin
             writesub(default, tmpfile, *args, &bloc)
           rescue
             File.unlink(tmpfile) if FileTest.exist?(tmpfile)
             raise
           end
 
           begin
             File.rename(tmpfile, file)
           rescue => detail
             Puppet.err "Could not rename #{file} to #{tmpfile}: #{detail}"
             File.unlink(tmpfile) if FileTest.exist?(tmpfile)
           end
         end
       end
     end
   end
 
   private
 
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
       raise ArgumentError, "Unknown default #{default}"
     end
 
     raise ArgumentError, "Default #{default} is not a file" unless obj.is_a? FileSetting
 
     obj
   end
 
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
     return unless self[:mkusers]
 
     @config.each do |name, setting|
       next unless setting.respond_to?(:owner)
       next unless sections.nil? or sections.include?(setting.section)
 
       if user = setting.owner and user != "root" and catalog.resource(:user, user).nil?
         resource = Puppet::Resource.new(:user, user, :parameters => {:ensure => :present})
         resource[:gid] = self[:group] if self[:group]
         catalog.add_resource resource
       end
       if group = setting.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
         catalog.add_resource Puppet::Resource.new(:group, group, :parameters => {:ensure => :present})
       end
     end
   end
 
   # Yield each search source in turn.
   def each_source(environment)
     searchpath(environment).each do |source|
       # Modify the source as necessary.
       source = self.run_mode if source == :run_mode
       yield source
     end
   end
 
   # Return all settings that have associated hooks; this is so
   # we can call them after parsing the configuration file.
   def settings_with_hooks
     @config.values.find_all { |setting| setting.respond_to?(:handle) }
   end
 
   # Extract extra setting information for files.
   def extract_fileinfo(string)
     result = {}
     value = string.sub(/\{\s*([^}]+)\s*\}/) do
       params = $1
       params.split(/\s*,\s*/).each do |str|
         if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
           param, value = $1.intern, $2
           result[param] = value
           raise ArgumentError, "Invalid file option '#{param}'" unless [:owner, :mode, :group].include?(param)
 
           if param == :mode and value !~ /^\d+$/
             raise ArgumentError, "File modes must be numbers"
           end
         else
           raise ArgumentError, "Could not parse '#{string}'"
         end
       end
       ''
     end
     result[:value] = value.sub(/\s*$/, '')
     result
   end
 
   # Convert arguments into booleans, integers, or whatever.
   def munge_value(value)
     # Handle different data types correctly
     return case value
       when /^false$/i; false
       when /^true$/i; true
       when /^\d+$/i; Integer(value)
       when true; true
       when false; false
       else
         value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
     end
   end
 
   # This method just turns a file in to a hash of hashes.
   def parse_file(file)
     text = read_file(file)
 
     result = Hash.new { |names, name|
       names[name] = {}
     }
 
     count = 0
 
     # Default to 'main' for the section.
     section = :main
     result[section][:_meta] = {}
     text.split(/\n/).each { |line|
       count += 1
       case line
       when /^\s*\[(\w+)\]\s*$/
         section = $1.intern # Section names
         # Add a meta section
         result[section][:_meta] ||= {}
       when /^\s*#/; next # Skip comments
       when /^\s*$/; next # Skip blanks
       when /^\s*(\w+)\s*=\s*(.*?)\s*$/ # settings
         var = $1.intern
 
         # We don't want to munge modes, because they're specified in octal, so we'll
         # just leave them as a String, since Puppet handles that case correctly.
         if var == :mode
           value = $2
         else
           value = munge_value($2)
         end
 
         # Check to see if this is a file argument and it has extra options
         begin
           if value.is_a?(String) and options = extract_fileinfo(value)
             value = options[:value]
             options.delete(:value)
             result[section][:_meta][var] = options
           end
           result[section][var] = value
         rescue Puppet::Error => detail
           detail.file = file
           detail.line = line
           raise
         end
       else
         error = Puppet::Error.new("Could not match line #{line}")
         error.file = file
         error.line = line
         raise error
       end
     }
 
     result
   end
 
   # Read the file in.
   def read_file(file)
     begin
       return File.read(file)
     rescue Errno::ENOENT
       raise ArgumentError, "No such file #{file}"
     rescue Errno::EACCES
       raise ArgumentError, "Permission denied to file #{file}"
     end
   end
 
   # Set file metadata.
   def set_metadata(meta)
     meta.each do |var, values|
       values.each do |param, value|
         @config[var].send(param.to_s + "=", value)
       end
     end
   end
 end
diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index d72187bb7..c830ef7f2 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,378 +1,382 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "with just an action" do
       before :all do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
         # suite run.
         #
         # It would be nice to fix this elsewhere, but it is actually hard to
         # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
         Signal.stubs(:trap)
         app.command_line.stubs(:args).returns %w{foo}
         app.preinit
         app.parse_options
       end
 
       it "should set the face based on the type" do
         app.face.name.should == :basetest
       end
 
       it "should find the action" do
         app.action.should be
         app.action.name.should == :foo
       end
     end
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
       expect { app.run }.to exit_with 1
       @logs.first.should_not be_nil
       @logs.first.message.should =~ /has no 'banana' action/
     end
 
     it "should use the default action if not given any arguments" do
       app.command_line.stubs(:args).returns []
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ { } ]
     end
 
     it "should use the default action if not given a valid one" do
       app.command_line.stubs(:args).returns %w{bar}
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ 'bar', { } ]
     end
 
     it "should have no action if not given a valid one and there is no default action" do
       app.command_line.stubs(:args).returns %w{bar}
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
       app.stubs(:main)
       expect { app.run }.to exit_with 1
       @logs.first.message.should =~ /has no 'bar' action./
     end
 
     [%w{something_I_cannot_do},
      %w{something_I_cannot_do argument}].each do |input|
       it "should report unknown actions nicely" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     [%w{something_I_cannot_do --unknown-option},
      %w{something_I_cannot_do argument --unknown-option}].each do |input|
       it "should report unknown actions even if there are unknown options" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     it "should report a sensible error when options with = fail" do
       app.command_line.stubs(:args).returns %w{--action=bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an action option is before the action" do
       app.command_line.stubs(:args).returns %w{--action foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an unknown option is before the action" do
       app.command_line.stubs(:args).returns %w{--bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should fail if an unknown option is after the action" do
       app.command_line.stubs(:args).returns %w{foo --bar}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
       app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should not skip when --foo=bar is given" do
       app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     { "boolean options before" => %w{--trace foo},
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
       it "should accept global boolean settings #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:trace].should be_true
       end
     end
 
     { "before" => %w{--syslogfacility user1 foo},
       " after" => %w{foo --syslogfacility user1}
     }.each do |name, args|
       it "should accept global settings with arguments #{name} the action" do
         app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
         Puppet[:syslogfacility].should == "user1"
       end
     end
 
     it "should handle application-level options", :'fails_on_ruby_1.9.2' => true do
       app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
       app.face.name.should == :basetest
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       expect { app.main }.to exit_with 0
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest)
       expect { app.main }.to exit_with 1
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with 0
     end
   end
 
   describe "error reporting" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.arguments = [{}]      # we always have options in there...
     end
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
       expect { app.main }.to exit_with 0
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
       expect { app.main }.not_to exit_with 0
     end
   end
 
   describe "#render" do
     before :each do
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
     end
 
     context "default rendering" do
       before :each do app.setup end
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
           app.render(input, {}).should == input
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render #{input.class} using JSON" do
           app.render(input, {}).should == input.to_pson.chomp
         end
       end
 
       it "should render a non-trivially-keyed Hash with using JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
         app.render(hash, {}).should == hash.to_pson.chomp
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
         object = Object.new
         hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
           5 => 5, 6.0 => 6 }
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
         app.render(hash, {}).should == <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
 one    1
 three  {}
 two    []
 EOT
       end
 
       it "should render a hash nicely with a multi-line value" do
         pending "Moving to PSON rather than PP makes this unsupportable."
         hash = {
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
         app.render(hash, {}).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
 text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
 EOT
       end
 
       describe "when setting the rendering method" do
         after do
           # need to reset the when_rendering block so that other tests can set it later
           app.action.instance_variable_set("@when_rendering", {})
         end
 
         it "should invoke the action rendering hook while rendering" do
           app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
           app.render("bi-polar?", {}).should == "bi-winning!"
         end
 
         it "should invoke the action rendering hook with args and options while rendering" do
           app.action.instance_variable_set("@when_rendering", {})
           app.action.when_invoked = proc { |name, options| 'just need to match arity for rendering' }
           app.action.set_rendering_method_for(
             :console,
             proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
           )
           app.render("bi-polar?", ['bob', {:altername => 'sue'}]).should == "I'm bob, no wait, I'm sue"
         end
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
         json = app.render({ :one => 1, :two => 2 }, {})
         json.should =~ /"one":\s*1\b/
         json.should =~ /"two":\s*2\b/
         PSON.parse(json).should == { "one" => 1, "two" => 2 }
       end
     end
 
     it "should fail early if asked to render an invalid format" do
       app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
       # We shouldn't get here, thanks to the exception, and our expectation on
       # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
       Puppet::Face[:help, :current].expects(:help).never
 
-      expect {
-        expect { app.run }.to exit_with 1
-      }.to have_printed(/I don't know how to render 'interpretive-dance'/)
+      Puppet.expects(:err).with("Could not parse options: I don't know how to render 'interpretive-dance'")
+
+      expect { app.run }.to exit_with 1
+
+      #expect {
+      #  expect { app.run }.to exit_with 1
+      #}.to have_printed(/I don't know how to render 'interpretive-dance'/)
     end
 
     it "should work if asked to render a NetworkHandler format" do
       app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/--- 3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/you invoked the 's' rendering hook/)
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index efd5b4678..043b0d080 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,617 +1,617 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 
 describe Puppet::Application do
 
   before do
     Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     @app.stubs(:name).returns("test_app")
     # avoid actually trying to parse any settings
     Puppet.settings.stubs(:parse)
   end
 
   describe "finding" do
     before do
       @klass = Puppet::Application
       @klass.stubs(:puts)
     end
 
     it "should find classes in the namespace" do
       @klass.find("Agent").should == @klass::Agent
     end
 
     it "should not find classes outside the namespace", :'fails_on_ruby_1.9.2' => true do
       expect { @klass.find("String") }.to exit_with 1
     end
 
     it "should exit if it can't find a class" do
       reg = "Unable to find application 'ThisShallNeverEverEverExist'.  "
       reg += "no such file to load -- puppet/application/thisshallneverevereverexist"
       @klass.expects(:puts).with(reg)
 
       expect { @klass.find("ThisShallNeverEverEverExist") }.to exit_with 1
     end
 
     it "#12114: should prevent File namespace collisions" do
       # have to require the file face once, then the second time around it would fail
       @klass.find("File").should == Puppet::Application::File
       @klass.find("File").should == Puppet::Application::File
     end
   end
 
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
       @appclass.run_mode.name.should == :agent
     end
   end
 
   it "should sadly and frighteningly allow run_mode to change at runtime" do
     class TestApp < Puppet::Application
       run_mode :master
       def run_command
         # This is equivalent to calling these methods externally to the
         # instance, but since this is what "real world" code is likely to do
         # (and we need the class anyway) we may as well test that. --daniel 2011-02-03
         set_run_mode self.class.run_mode "agent"
       end
     end
 
     Puppet[:run_mode].should == "user"
 
     expect {
       app = TestApp.new
 
       Puppet[:run_mode].should == "master"
 
       app.run
 
       app.class.run_mode.name.should == :agent
       $puppet_application_mode.name.should == :agent
     }.should_not raise_error
 
     Puppet[:run_mode].should == "agent"
   end
 
   it "it should not allow run mode to be set multiple times" do
     pending "great floods of tears, you can do this right now" # --daniel 2011-02-03
     app = Puppet::Application.new
     expect {
       app.set_run_mode app.class.run_mode "master"
       $puppet_application_mode.name.should == :master
       app.set_run_mode app.class.run_mode "agent"
       $puppet_application_mode.name.should == :agent
     }.should raise_error
   end
 
   it "should explode when an invalid run mode is set at runtime, for great victory"
   # ...but you can, and while it will explode, that only happens too late for
   # us to easily test. --daniel 2011-02-03
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
 
   it "should have a read accessor to options" do
     @app.should respond_to(:options)
   end
 
   it "should include a default setup method" do
     @app.should respond_to(:setup)
   end
 
   it "should include a default preinit method" do
     @app.should respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
     @app.should respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
     @app.expects( :main )
     @app.run_command
   end
 
   it "should initialize the Puppet Instrumentation layer on creation" do
     Puppet::Util::Instrumentation.expects(:init)
     Class.new(Puppet::Application).new
   end
 
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
       Puppet::Application.clear!
     end
 
     it 'should have nil run_status' do
       Puppet::Application.run_status.should be_nil
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return false for interrupted?' do
       Puppet::Application.interrupted?.should be_false
     end
 
     it 'should return true for clear?' do
       Puppet::Application.clear?.should be_true
     end
   end
 
   describe 'after invoking stop!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.stop!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :stop_requested' do
       Puppet::Application.run_status.should == :stop_requested
     end
 
     it 'should return true for stop_requested?' do
       Puppet::Application.stop_requested?.should be_true
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when invoking restart!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.restart!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :restart_requested' do
       Puppet::Application.run_status.should == :restart_requested
     end
 
     it 'should return true for restart_requested?' do
       Puppet::Application.restart_requested?.should be_true
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
       target = mock 'target'
       target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
       target = mock 'target'
       target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution', :'fails_on_ruby_1.9.2' => true do
         Puppet::Application.run_status = nil
         target = mock 'target'
         target.expects(:some_method).once
         old_handler = trap('HUP') { target.some_method }
         begin
           Puppet::Application.controlled_run do
             Puppet::Application.run_status = :restart_requested
           end
         ensure
           trap('HUP', old_handler)
         end
       end
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
   end
 
   describe "when parsing command-line options" do
 
     before :each do
       @app.command_line.stubs(:args).returns([])
 
       Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
       option_parser = stub "option parser"
       option_parser.stubs(:on)
       option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
       OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should get options from Puppet.settings.optparse_addargs" do
       Puppet.settings.expects(:optparse_addargs).returns([])
 
       @app.parse_options
     end
 
     it "should add Puppet.settings options to OptionParser" do
       Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
       Puppet.settings.expects(:handlearg).with("--option", 'true')
       @app.command_line.stubs(:args).returns(["--option"])
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
 
       it "should call exit" do
         @app.stubs(:puts)
         expect { @app.handle_help(nil) }.to exit_with 0
       end
 
     end
 
     describe "when using --version" do
       it "should declare a version option" do
         @app.should respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
         @app.stubs(:puts)
         expect { @app.handle_version(nil) }.to exit_with 0
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
         @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
         @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if handle_unknown says so" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if there is no handle_unknown method" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:respond_to?).returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should transform boolean false value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "false")
         @app.handlearg("--option", false)
       end
 
       it "should transform boolean true value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--option", true)
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--no-option", "false")
         @app.handlearg("--[no-]option", false)
       end
 
     end
   end
 
   describe "when calling default setup" do
 
     before :each do
       @app.stubs(:should_parse_config?).returns(false)
       @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
         @app.setup
         Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       @app.setup
     end
 
   end
 
   describe "when configuring routes" do
     include PuppetSpec::Files
 
     before :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     after :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     it "should use the routes specified for only the active application" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
           test_app:
             node:
               terminus: exec
           other_app:
             node:
               terminus: plain
             catalog:
               terminus: invalid
         ROUTES
       end
 
       @app.configure_indirector_routes
 
       Puppet::Node.indirection.terminus_class.should == 'exec'
     end
 
     it "should not fail if the route file doesn't exist" do
       Puppet[:route_file] = "/dev/null/non-existent"
 
       expect { @app.configure_indirector_routes }.should_not raise_error
     end
 
     it "should raise an error if the routes file is invalid" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
          invalid : : yaml
         ROUTES
       end
 
       expect { @app.configure_indirector_routes }.should raise_error
     end
   end
 
   describe "when running" do
 
     before :each do
       @app.stubs(:preinit)
       @app.stubs(:setup)
       @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
       @app.stubs(:run_command)
 
       @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
       @app.stubs(:run_command)
 
       @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
 
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should parse Puppet configuration if should_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_parse_config
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should not parse_option if should_not_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_not_parse_config
 
       Puppet.settings.expects(:parse).never
 
       @app.run
     end
 
     it "should parse Puppet configuration if needed" do
       @app.stubs(:run_command)
       @app.stubs(:should_parse_config?).returns(true)
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should call run_command" do
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
       @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
   end
 
   describe "when metaprogramming" do
 
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
         end
 
         @app.should respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
         @app.should respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
         @app.should respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
         it "should create a new method with it" do
           @app.class.option("--[no-]test2","-t") do
             raise "I can't believe it, it works!"
           end
 
           lambda { @app.handle_test2 }.should raise_error
         end
 
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
 
           @app.parse_options
         end
 
         it "should pass a block that calls our defined method" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
           @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
 
           @app.parse_options
         end
       end
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
 
         it "should give to OptionParser a block that adds the the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
           @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
       end
     end
 
   end
 end
diff --git a/spec/unit/util/logging_spec.rb b/spec/unit/util/logging_spec.rb
index 6f0e6b76b..4eebad8fd 100755
--- a/spec/unit/util/logging_spec.rb
+++ b/spec/unit/util/logging_spec.rb
@@ -1,119 +1,125 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/logging'
 
 class LoggingTester
   include Puppet::Util::Logging
 end
 
 describe Puppet::Util::Logging do
   before do
     @logger = LoggingTester.new
   end
 
   Puppet::Util::Log.eachlevel do |level|
     it "should have a method for sending '#{level}' logs" do
       @logger.should respond_to(level)
     end
   end
 
   it "should have a method for sending a log with a specified log level" do
     @logger.expects(:to_s).returns "I'm a string!"
     Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" and args[:level] == "loglevel" and args[:message] == "mymessage" }
 
     @logger.send_log "loglevel", "mymessage"
   end
 
   describe "when sending a log" do
     it "should use the Log's 'create' entrance method" do
       Puppet::Util::Log.expects(:create)
 
       @logger.notice "foo"
     end
 
     it "should send itself converted to a string as the log source" do
       @logger.expects(:to_s).returns "I'm a string!"
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "I'm a string!" }
 
       @logger.notice "foo"
     end
 
     it "should queue logs sent without a specified destination" do
       Puppet::Util::Log.close_all
       Puppet::Util::Log.expects(:queuemessage)
 
       @logger.notice "foo"
     end
 
     it "should use the path of any provided resource type" do
       resource = Puppet::Type.type(:host).new :name => "foo"
 
       resource.expects(:path).returns "/path/to/host".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/host" }
 
       resource.notice "foo"
     end
 
     it "should use the path of any provided resource parameter" do
       resource = Puppet::Type.type(:host).new :name => "foo"
 
       param = resource.parameter(:name)
 
       param.expects(:path).returns "/path/to/param".to_sym
 
       Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/param" }
 
       param.notice "foo"
     end
 
     it "should send the provided argument as the log message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo" }
 
       @logger.notice "foo"
     end
 
     it "should join any provided arguments into a single string for the message" do
       Puppet::Util::Log.expects(:create).with { |args| args[:message] == "foo bar baz" }
 
       @logger.notice ["foo", "bar", "baz"]
     end
 
     [:file, :line, :tags].each do |attr|
       it "should include #{attr} if available" do
         @logger.singleton_class.send(:attr_accessor, attr)
 
         @logger.send(attr.to_s + "=", "myval")
 
         Puppet::Util::Log.expects(:create).with { |args| args[attr] == "myval" }
         @logger.notice "foo"
       end
     end
   end
 
   describe "when sending a deprecation warning" do
     it "should log the message with warn" do
-      @logger.expects(:warning).with('foo')
+      @logger.expects(:warning).with do |msg|
+        msg =~ /^foo\n/
+      end
       @logger.deprecation_warning 'foo'
     end
 
     it "should only log each offending line once" do
-      @logger.expects(:warning).with('foo').once
+      @logger.expects(:warning).with do |msg|
+        msg =~ /^foo\n/
+      end .once
       5.times { @logger.deprecation_warning 'foo' }
     end
 
     it "should only log the first 100 messages" do
       (1..100).each { |i|
-        @logger.expects(:warning).with(i).once
+        @logger.expects(:warning).with do |msg|
+          msg =~ /^#{i}\n/
+        end .once
         # since the deprecation warning will only log each offending line once, we have to do some tomfoolery
         # here in order to make it think each of these calls is coming from a unique call stack; we're basically
         # mocking the method that it would normally use to find the call stack.
         @logger.expects(:get_deprecation_offender).returns("deprecation log count test ##{i}")
         @logger.deprecation_warning i
       }
       @logger.expects(:warning).with(101).never
       @logger.deprecation_warning 101
     end
   end
 end