diff --git a/lib/puppet/application/inspect.rb b/lib/puppet/application/inspect.rb
index 6737128aa..f3a005b53 100644
--- a/lib/puppet/application/inspect.rb
+++ b/lib/puppet/application/inspect.rb
@@ -1,190 +1,191 @@
 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}"
           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}"
       end
     end
   end
 end
diff --git a/lib/puppet/configurer.rb b/lib/puppet/configurer.rb
index 83b5a9ad4..5a0ec589e 100644
--- a/lib/puppet/configurer.rb
+++ b/lib/puppet/configurer.rb
@@ -1,247 +1,248 @@
 # 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
   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]
 
     download_fact_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
         retrieve_and_apply_catalog(options, fact_options)
       rescue SystemExit,NoMemoryError
         raise
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err "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}"
   end
 
   def save_last_run_summary(report)
     Puppet::Util::FileLocking.writelock(Puppet[:lastrunfile], 0660) do |file|
       file.print YAML.dump(report.raw_summary)
     end
   rescue => detail
     puts detail.backtrace if Puppet[:trace]
     Puppet.err "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.execute([command])
       true
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "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}"
     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}"
     return nil
   end
 end
diff --git a/lib/puppet/face/catalog.rb b/lib/puppet/face/catalog.rb
index 10b15d250..efd4ee7f7 100644
--- a/lib/puppet/face/catalog.rb
+++ b/lib/puppet/face/catalog.rb
@@ -1,130 +1,131 @@
 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}"
       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/transaction.rb b/lib/puppet/transaction.rb
index 3152d768d..a15a070ad 100644
--- a/lib/puppet/transaction.rb
+++ b/lib/puppet/transaction.rb
@@ -1,384 +1,384 @@
 # 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
     prepare
 
     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
         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)
     raise Puppet::DevError,"Depthfirst resources are not supported by eval_generate" if resource.depthfirst?
     begin
       made = resource.eval_generate.uniq.reverse
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       resource.err "Failed to generate additional resources using 'eval_generate: #{detail}"
       return
     end
     made.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
     sentinal = Puppet::Type::Whit.new(:name => "completed_#{resource.title}", :catalog => resource.catalog)
     relationship_graph.adjacent(resource,:direction => :out,:type => :edges).each { |e|
       add_conditional_directed_dependency(sentinal, e.target, e.label)
       relationship_graph.remove_edge! e
     }
     default_label = Puppet::Resource::Catalog::Default_label
     made.each do |res|
       add_conditional_directed_dependency(made.find { |r| r != res && r.name == res.name[0,r.name.length]} || resource, res)
       add_conditional_directed_dependency(res, sentinal, default_label)
     end
     add_conditional_directed_dependency(resource, sentinal, default_label)
   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}"
     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
 
   # Collect any dynamically generated resources.  This method is called
   # before the transaction starts.
   def xgenerate
     @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)
+    @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)
   end
 
   # Prefetch any providers that support it.  We don't support prefetching
   # types, just providers.
   def prefetch
     prefetchers = {}
     @catalog.vertices.each do |resource|
       if provider = resource.provider and provider.class.respond_to?(:prefetch)
         prefetchers[provider.class] ||= {}
         prefetchers[provider.class][resource.name] = resource
       end
     end
 
     # Now call prefetch, passing in the resources so that the provider instances can be replaced.
     prefetchers.each do |provider, resources|
       Puppet.debug "Prefetching #{provider.name} resources for #{provider.resource_type.name}"
       begin
         provider.prefetch(resources)
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err "Could not prefetch #{provider.resource_type.name} provider '#{provider.name}': #{detail}"
       end
     end
   end
 
   # Prepare to evaluate the resources in a transaction.
   def prepare
     # Now add any dynamically generated resources
     xgenerate
 
     # Then prefetch.  It's important that we generate and then prefetch,
     # so that any generated resources also get prefetched.
     prefetch
   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
     attr_reader :real_graph,:transaction,:ready,:generated,:done,:unguessable_deterministic_key
     def initialize(real_graph,transaction)
       @real_graph = real_graph
       @transaction = transaction
       @ready = {}
       @generated = {}
       @done = {}
       @unguessable_deterministic_key = Hash.new { |h,k| h[k] = Digest::SHA1.hexdigest("NaCl, MgSO4 (salts) and then #{k.title}") }
       vertices.each { |v| check_if_now_ready(v) }
     end
     def method_missing(*args,&block)
       real_graph.send(*args,&block)
     end
     def add_vertex(v)
       real_graph.add_vertex(v)
       check_if_now_ready(v) # ?????????????????????????????????????????
     end
     def add_edge(f,t,label=nil)
       ready.delete(t)
       real_graph.add_edge(f,t,label)
     end
     def check_if_now_ready(r)
       ready[r] = true if direct_dependencies_of(r).all? { |r2| done[r2] }
     end
     def next_resource
       ready.keys.sort_by { |r0| unguessable_deterministic_key[r0] }.first
     end
     def traverse(&block)
       real_graph.report_cycles_in_graph
       while (r = next_resource) && !transaction.stop_processing?
         if !generated[r] && r.respond_to?(:eval_generate)
           transaction.eval_generate(r)
           generated[r] = true
         else
           ready.delete(r)
           yield r
           done[r] = true
           direct_dependents_of(r).each { |v| check_if_now_ready(v) }
         end
       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/report.rb b/lib/puppet/transaction/report.rb
index 807163961..b77a87e3c 100644
--- a/lib/puppet/transaction/report.rb
+++ b/lib/puppet/transaction/report.rb
@@ -1,193 +1,194 @@
 require 'puppet'
 require 'puppet/indirector'
 
 # A class for reporting what happens on each client.  Reports consist of
 # two types of data:  Logs and Metrics.  Logs are the output that each
 # change produces, and Metrics are all of the numerical data involved
 # in the transaction.
 class Puppet::Transaction::Report
   extend Puppet::Indirector
 
   indirects :report, :terminus_class => :processor
 
-  attr_accessor :configuration_version, :host
+  attr_accessor :configuration_version, :host, :environment
   attr_reader :resource_statuses, :logs, :metrics, :time, :kind, :status
 
   # This is necessary since Marshall doesn't know how to
   # dump hash with default proc (see below @records)
   def self.default_format
     :yaml
   end
 
   def <<(msg)
     @logs << msg
     self
   end
 
   def add_times(name, value)
     @external_times[name] = value
   end
 
   def add_metric(name, hash)
     metric = Puppet::Util::Metric.new(name)
 
     hash.each do |name, value|
       metric.newvalue(name, value)
     end
 
     @metrics[metric.name] = metric
     metric
   end
 
   def add_resource_status(status)
     @resource_statuses[status.resource] = status
   end
 
   def compute_status(resource_metrics, change_metric)
     if (resource_metrics["failed"] || 0) > 0
       'failed'
     elsif change_metric > 0
       'changed'
     else
       'unchanged'
     end
   end
 
   def prune_internal_data
     resource_statuses.delete_if {|name,res| res.resource_type == 'Whit'}
   end
 
   def finalize_report
     prune_internal_data
 
     resource_metrics = add_metric(:resources, calculate_resource_metrics)
     add_metric(:time, calculate_time_metrics)
     change_metric = calculate_change_metric
     add_metric(:changes, {"total" => change_metric})
     add_metric(:events, calculate_event_metrics)
     @status = compute_status(resource_metrics, change_metric)
   end
 
-  def initialize(kind, configuration_version=nil)
+  def initialize(kind, configuration_version=nil, environment=nil)
     @metrics = {}
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
     @host = Puppet[:node_name_value]
     @time = Time.now
     @kind = kind
     @report_format = 2
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
+    @environment = environment
     @status = 'failed' # assume failed until the report is finalized
   end
 
   def name
     host
   end
 
   # Provide a human readable textual summary of this report.
   def summary
     report = raw_summary
 
     ret = ""
     report.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key|
       ret += "#{Puppet::Util::Metric.labelize(key)}:\n"
 
       report[key].keys.sort { |a,b|
         # sort by label
         if a == :total
           1
         elsif b == :total
           -1
         else
           report[key][a].to_s <=> report[key][b].to_s
         end
       }.each do |label|
         value = report[key][label]
         next if value == 0
         value = "%0.2f" % value if value.is_a?(Float)
         ret += "   %15s %s\n" % [Puppet::Util::Metric.labelize(label) + ":", value]
       end
     end
     ret
   end
 
   # Provide a raw hash summary of this report.
   def raw_summary
     report = {}
 
     @metrics.each do |name, metric|
       key = metric.name.to_s
       report[key] = {}
       metric.values.each do |name, label, value|
         report[key][name.to_s] = value
       end
       report[key]["total"] = 0 unless key == "time" or report[key].include?("total")
     end
     (report["time"] ||= {})["last_run"] = Time.now.tv_sec
     report
   end
 
   # Based on the contents of this report's metrics, compute a single number
   # that represents the report. The resulting number is a bitmask where
   # individual bits represent the presence of different metrics.
   def exit_status
     status = 0
     status |= 2 if @metrics["changes"]["total"] > 0
     status |= 4 if @metrics["resources"]["failed"] > 0
     status
   end
 
   def to_yaml_properties
     (instance_variables - ["@external_times"]).sort
   end
 
   private
 
   def calculate_change_metric
     resource_statuses.map { |name, status| status.change_count || 0 }.inject(0) { |a,b| a+b }
   end
 
   def calculate_event_metrics
     metrics = Hash.new(0)
     metrics["total"] = 0
     resource_statuses.each do |name, status|
       metrics["total"] += status.events.length
       status.events.each do |event|
         metrics[event.status] += 1
       end
     end
 
     metrics
   end
 
   def calculate_resource_metrics
     metrics = Hash.new(0)
     metrics["total"] = resource_statuses.length
 
     resource_statuses.each do |name, status|
       Puppet::Resource::Status::STATES.each do |state|
         metrics[state.to_s] += 1 if status.send(state)
       end
     end
 
     metrics
   end
 
   def calculate_time_metrics
     metrics = Hash.new(0)
     resource_statuses.each do |name, status|
       type = Puppet::Resource.new(name).type
       metrics[type.to_s.downcase] += status.evaluation_time if status.evaluation_time
     end
 
     @external_times.each do |name, value|
       metrics[name.to_s.downcase] = value
     end
 
     metrics["total"] = metrics.values.inject(0) { |a,b| a+b }
 
     metrics
   end
 end
diff --git a/spec/unit/transaction/report_spec.rb b/spec/unit/transaction/report_spec.rb
index fe5c2e218..6865409ca 100755
--- a/spec/unit/transaction/report_spec.rb
+++ b/spec/unit/transaction/report_spec.rb
@@ -1,308 +1,318 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/transaction/report'
 
 describe Puppet::Transaction::Report do
   include PuppetSpec::Files
   before do
     Puppet::Util::Storage.stubs(:store)
   end
 
   it "should set its host name to the node_name_value" do
     Puppet[:node_name_value] = 'mynode'
     Puppet::Transaction::Report.new("apply").host.should == "mynode"
   end
 
   it "should return its host name as its name" do
     r = Puppet::Transaction::Report.new("apply")
     r.name.should == r.host
   end
 
   it "should create an initialization timestamp" do
     Time.expects(:now).returns "mytime"
     Puppet::Transaction::Report.new("apply").time.should == "mytime"
   end
 
   it "should take a 'kind' as an argument" do
     Puppet::Transaction::Report.new("inspect").kind.should == "inspect"
   end
 
   it "should take a 'configuration_version' as an argument" do
-    Puppet::Transaction::Report.new("inspect", "some configuration version").configuration_version.should == "some configuration version"
+    Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").configuration_version.should == "some configuration version"
   end
 
   it "should be able to set configuration_version" do
     report = Puppet::Transaction::Report.new("inspect")
     report.configuration_version = "some version"
     report.configuration_version.should == "some version"
   end
 
+  it "should take 'environment' as an argument" do
+    Puppet::Transaction::Report.new("inspect", "some configuration version", "some environment").environment.should == "some environment"
+  end
+
+  it "should be able to set environment" do
+    report = Puppet::Transaction::Report.new("inspect")
+    report.environment = "some environment"
+    report.environment.should == "some environment"
+  end
+
   it "should not include whits" do
     Puppet::FileBucket::File.indirection.stubs(:save)
 
     filename = tmpfile('whit_test')
     file = Puppet::Type.type(:file).new(:path => filename)
 
     catalog = Puppet::Resource::Catalog.new
     catalog.add_resource(file)
 
     report = Puppet::Transaction::Report.new("apply")
 
     catalog.apply(:report => report)
     report.finalize_report
 
     report.resource_statuses.values.any? {|res| res.resource_type =~ /whit/i}.should be_false
     report.metrics['time'].values.any? {|metric| metric.first =~ /whit/i}.should be_false
   end
 
   describe "when accepting logs" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add new logs to the log list" do
       @report << "log"
       @report.logs[-1].should == "log"
     end
 
     it "should return self" do
       r = @report << "log"
       r.should equal(@report)
     end
   end
 
   describe "when accepting resource statuses" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     it "should add each status to its status list" do
       status = stub 'status', :resource => "foo"
       @report.add_resource_status status
       @report.resource_statuses["foo"].should equal(status)
     end
   end
 
   describe "when using the indirector" do
     it "should redirect :save to the indirection" do
       Facter.stubs(:value).returns("eh")
       @indirection = stub 'indirection', :name => :report
       Puppet::Transaction::Report.stubs(:indirection).returns(@indirection)
       report = Puppet::Transaction::Report.new("apply")
       @indirection.expects(:save)
       Puppet::Transaction::Report.indirection.save(report)
     end
 
     it "should default to the 'processor' terminus" do
       Puppet::Transaction::Report.indirection.terminus_class.should == :processor
     end
 
     it "should delegate its name attribute to its host method" do
       report = Puppet::Transaction::Report.new("apply")
       report.expects(:host).returns "me"
       report.name.should == "me"
     end
   end
 
   describe "when computing exit status" do
     it "should produce 2 if changes are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 0})
       report.exit_status.should == 2
     end
 
     it "should produce 4 if failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 0})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 4
     end
 
     it "should produce 6 if both changes and failures are present" do
       report = Puppet::Transaction::Report.new("apply")
       report.add_metric("changes", {"total" => 1})
       report.add_metric("resources", {"failed" => 1})
       report.exit_status.should == 6
     end
   end
 
   describe "before finalizing the report" do
     it "should have a status of 'failed'" do
       report = Puppet::Transaction::Report.new("apply")
       report.status.should == 'failed'
     end
   end
 
   describe "when finalizing the report" do
     before do
       @report = Puppet::Transaction::Report.new("apply")
     end
 
     def metric(name, value)
       if metric = @report.metrics[name.to_s]
         metric[value]
       else
         nil
       end
     end
 
     def add_statuses(count, type = :file)
       count.times do |i|
         status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => make_absolute("/my/path#{i}")))
         yield status if block_given?
         @report.add_resource_status status
       end
     end
 
 
     [:time, :resources, :changes, :events].each do |type|
       it "should add #{type} metrics" do
         @report.finalize_report
         @report.metrics[type.to_s].should be_instance_of(Puppet::Transaction::Metric)
       end
     end
 
     describe "for resources" do
       it "should provide the total number of resources" do
         add_statuses(3)
 
         @report.finalize_report
         metric(:resources, "total").should == 3
       end
 
       Puppet::Resource::Status::STATES.each do |state|
         it "should provide the number of #{state} resources as determined by the status objects" do
           add_statuses(3) { |status| status.send(state.to_s + "=", true) }
 
           @report.finalize_report
           metric(:resources, state.to_s).should == 3
         end
       end
 
       it "should mark the report as 'failed' if there are failing resources" do
         add_statuses(1) { |status| status.failed = true }
         @report.finalize_report
         @report.status.should == 'failed'
       end
     end
 
     describe "for changes" do
       it "should provide the number of changes from the resource statuses and mark the report as 'changed'" do
         add_statuses(3) { |status| 3.times { status << Puppet::Transaction::Event.new(:status => 'success') } }
         @report.finalize_report
         metric(:changes, "total").should == 9
         @report.status.should == 'changed'
       end
 
       it "should provide a total even if there are no changes, and mark the report as 'unchanged'" do
         @report.finalize_report
         metric(:changes, "total").should == 0
         @report.status.should == 'unchanged'
       end
     end
 
     describe "for times" do
       it "should provide the total amount of time for each resource type" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end
         add_statuses(3, :exec) do |status|
           status.evaluation_time = 2
         end
         add_statuses(3, :tidy) do |status|
           status.evaluation_time = 3
         end
 
         @report.finalize_report
 
         metric(:time, "file").should == 3
         metric(:time, "exec").should == 6
         metric(:time, "tidy").should == 9
       end
 
       it "should add any provided times from external sources" do
         @report.add_times :foobar, 50
         @report.finalize_report
         metric(:time, "foobar").should == 50
       end
 
       it "should have a total time" do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1.25
         end
         @report.add_times :config_retrieval, 0.5
         @report.finalize_report
         metric(:time, "total").should == 4.25
       end
     end
 
     describe "for events" do
       it "should provide the total number of events" do
         add_statuses(3) do |status|
           3.times { |i| status.add_event(Puppet::Transaction::Event.new :status => 'success') }
         end
         @report.finalize_report
         metric(:events, "total").should == 9
       end
 
       it "should provide the total even if there are no events" do
         @report.finalize_report
         metric(:events, "total").should == 0
       end
 
       Puppet::Transaction::Event::EVENT_STATUSES.each do |status_name|
         it "should provide the number of #{status_name} events" do
           add_statuses(3) do |status|
             3.times do |i|
               event = Puppet::Transaction::Event.new
               event.status = status_name
               status.add_event(event)
             end
           end
 
           @report.finalize_report
           metric(:events, status_name).should == 9
         end
       end
     end
   end
 
   describe "when producing a summary" do
     before do
       resource = Puppet::Type.type(:notify).new(:name => "testing")
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource resource
       trans = catalog.apply
 
       @report = trans.report
       @report.finalize_report
     end
 
     %w{changes time resources events}.each do |main|
       it "should include the key #{main} in the raw summary hash" do
         @report.raw_summary.should be_key main
       end
     end
 
     it "should include the last run time in the raw summary hash" do
       Time.stubs(:now).returns(Time.utc(2010,11,10,12,0,24))
       @report.raw_summary["time"]["last_run"].should == 1289390424
     end
 
     %w{Changes Total Resources Time Events}.each do |main|
       it "should include information on #{main} in the textual summary" do
         @report.summary.should be_include(main)
       end
     end
   end
 
   describe "when outputting yaml" do
     it "should not include @external_times" do
       report = Puppet::Transaction::Report.new('apply')
       report.add_times('config_retrieval', 1.0)
       report.to_yaml_properties.should_not include('@external_times')
     end
   end
 end