puppet 4.0.0 → 4.9.1

data/lib/puppet/reference/report.rb

@@ -5,19 +5,16 @@ report = Puppet::Util::Reference.newreference :report, :doc => "All available tr
 end
 
 report.header = "
-Puppet clients can report back to the server after each transaction.  This
-transaction report is sent as a YAML dump of the
-`Puppet::Transaction::Report` class and includes every log message that was
-generated during the transaction along with as many metrics as Puppet knows how
-to collect.  See [Reports and Reporting](http://docs.puppetlabs.com/guides/reporting.html) for more information on how to use reports.
+Puppet can generate a report after applying a catalog. This report includes
+events, log messages, resource statuses, and metrics and metadata about the run.
+Puppet agent sends its report to a Puppet master server, and Puppet apply
+processes its own reports.
 
-Currently, clients default to not sending in reports; you can enable reporting
-by setting the `report` parameter to true.
+Puppet master and Puppet apply will handle every report with a set of report
+processors, configurable with the `reports` setting in puppet.conf. This page
+documents the built-in report processors.
 
-To use a report, set the `reports` parameter on the server; multiple
-reports must be comma-separated.  You can also specify `none` to disable
-reports entirely.
-
-Puppet provides multiple report handlers that will process client reports:
+See [About Reporting](https://docs.puppetlabs.com/puppet/latest/reference/reporting_about.html)
+for more details.
 
 "

data/lib/puppet/reference/type.rb

@@ -36,7 +36,7 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
 - *Providers* provide low-level functionality for a given resource type.  This is
   usually in the form of calling out to external commands.
 
-  When required binaries are specified for providers, fully qualifed paths
+  When required binaries are specified for providers, fully qualified paths
   indicate that the binary must exist at that specific path and unqualified
   binaries indicate that Puppet will search for the binary using the shell
   path.

data/lib/puppet/reports.rb

@@ -54,7 +54,11 @@ class Puppet::Reports
   def self.register_report(name, options = {}, &block)
     name = name.intern
 
-    mod = genmodule(name, :extend => Puppet::Util::Docs, :hash => instance_hash(:report), :block => block)
+    mod = genmodule(name,
+                    :extend    => Puppet::Util::Docs,
+                    :hash      => instance_hash(:report),
+                    :overwrite => true,
+                    :block     => block)
 
     mod.useyaml = true if options[:useyaml]
 

data/lib/puppet/resource/capability_finder.rb

@@ -0,0 +1,128 @@
+#
+# A helper module to look a capability up from PuppetDB
+#
+# @todo lutter 2015-03-10: determine whether this should be based on
+# Puppet::Pops::Evaluator::Collectors, or at least use
+# Puppet::Util::Puppetdb::Http
+
+require 'net/http'
+require 'cgi'
+require 'json'
+
+# @api private
+module Puppet::Resource::CapabilityFinder
+
+  # Looks up a capability resource from PuppetDB. Capability resources are
+  # required to be unique per environment and code id. If multiple copies of a
+  # capability resource are found, the one matching the current code id is
+  # used.
+  #
+  # @param environment [String] environment name
+  # @param code_id [String,nil] code_id of the catalog
+  # @param cap [Puppet::Type] the capability resource type instance
+  # @return [Puppet::Resource,nil] The found capability resource or `nil` if it could not be found
+  def self.find(environment, code_id, cap)
+    unless Puppet::Util.const_defined?('Puppetdb')
+      raise Puppet::DevError, 'PuppetDB is not available'
+    end
+
+    resources = search(nil, nil, cap)
+
+    if resources.size > 1
+      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by environment #{environment}"
+      resources = resources.select { |r| r['tags'].any? { |t| t == "producer:#{environment}" } }
+    end
+
+    if resources.size > 1 && code_id
+      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by code id #{code_id}"
+      resources = search(environment, code_id, cap)
+    end
+
+    if resources.size > 1
+      raise Puppet::DevError,
+        "Unexpected response from PuppetDB when looking up #{cap}:\n" \
+        "expected exactly one resource but got #{resources.size};\n" \
+        "returned data is:\n#{resources.inspect}"
+    end
+
+    if resource_hash = resources.first
+      resource_hash['type'] = cap.resource_type
+      instantiate_resource(resource_hash)
+    else
+      Puppet.debug "Could not find capability resource #{cap} in PuppetDB"
+      nil
+    end
+  end
+
+  def self.search(environment, code_id, cap)
+    query_terms = [
+      'and',
+      ['=', 'type', cap.type.capitalize],
+      ['=', 'title', cap.title.to_s],
+    ]
+
+    if environment.nil?
+      query_terms << ['~', 'tag', "^producer:"]
+    else
+      query_terms << ['=', 'tag', "producer:#{environment}"]
+    end
+
+    unless code_id.nil?
+      query_terms << ['in', 'certname',
+        ['extract', 'certname',
+          ['select_catalogs',
+            ['=', 'code_id', code_id]]]]
+    end
+
+    Puppet.notice "Looking up capability #{cap} in PuppetDB: #{query_terms}"
+
+    query_puppetdb(query_terms)
+  end
+
+  def self.query_puppetdb(query)
+    begin
+      # If using PuppetDB >= 4, use the API method query_puppetdb()
+      result = if Puppet::Util::Puppetdb.respond_to?(:query_puppetdb)
+        # PuppetDB 4 uses a unified query endpoint, so we have to specify what we're querying
+        Puppet::Util::Puppetdb.query_puppetdb(["from", "resources", query])
+      # For PuppetDB < 4, use the old internal method action()
+      else
+        url = "/pdb/query/v4/resource?query=#{CGI.escape(query.to_json)}"
+        response = Puppet::Util::Puppetdb::Http.action(url) do |conn, uri|
+          conn.get(uri, { 'Accept' => 'application/json'})
+        end
+        JSON.parse(response.body)
+      end
+
+      # The format of the response body is documented at
+      #   http://docs.puppetlabs.com/puppetdb/3.0/api/query/v4/resources.html#response-format
+      unless result.is_a?(Array)
+        raise Puppet::DevError,
+        "Unexpected response from PuppetDB when looking up #{cap}: " \
+          "expected an Array but got #{result.inspect}"
+      end
+
+      result
+    rescue JSON::JSONError => e
+      raise Puppet::DevError,
+        "Invalid JSON from PuppetDB when looking up #{cap}\n#{e}"
+    end
+  end
+
+  private
+
+  def self.instantiate_resource(resource_hash)
+    real_type = resource_hash['type']
+    resource = Puppet::Resource.new(real_type, resource_hash['title'])
+    real_type.parameters.each do |param|
+      param = param.to_s
+      next if param == 'name'
+      if value = resource_hash['parameters'][param]
+        resource[param] = value
+      else
+        Puppet.debug "No capability value for #{resource}->#{param}"
+      end
+    end
+    return resource
+  end
+end

data/lib/puppet/resource/catalog.rb

@@ -3,6 +3,9 @@ require 'puppet/indirector'
 require 'puppet/transaction'
 require 'puppet/util/tagging'
 require 'puppet/graph'
+require 'securerandom'
+
+require 'puppet/resource/capability_finder'
 
 # 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
@@ -27,6 +30,25 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # is up to date.
   attr_accessor :version
 
+  # The id of the code input to the compiler.
+  attr_accessor :code_id
+
+  # The UUID of the catalog
+  attr_accessor :catalog_uuid
+
+  # @return [Integer] catalog format version number. This value is constant
+  #  for a given version of Puppet; it is incremented when a new release of
+  #  Puppet changes the API for the various objects that make up the catalog.
+  attr_accessor :catalog_format
+
+  # Inlined file metadata for non-recursive find
+  # A hash of title => metadata
+  attr_accessor :metadata
+
+  # Inlined file metadata for recursive search
+  # A hash of title => { source => [metadata, ...] }
+  attr_accessor :recursive_metadata
+
   # How long this catalog took to retrieve.  Used for reporting stats.
   attr_accessor :retrieval_duration
 
@@ -62,7 +84,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   def title_key_for_ref( ref )
     s = ref.index('[')
-    e = ref.index(']')
+    e = ref.rindex(']')
     if s && e && e > s
       a = [ref[0, s], ref[s+1, e-s-1]]
     else
@@ -71,6 +93,27 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     return a
   end
 
+  def add_resource_before(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} before #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx)
+    end
+  end
+
+  # Add `resources` to the catalog after `other`. WARNING: adding
+  # multiple resources will produce the reverse ordering, e.g. calling
+  # `add_resource_after(A, [B,C])` will result in `[A,C,B]`.
+  def add_resource_after(other, *resources)
+    resources.each do |resource|
+      other_title_key = title_key_for_ref(other.ref)
+      idx = @resources.index(other_title_key)
+      raise ArgumentError, "Cannot add resource #{resource.ref} after #{other.ref} because #{other.ref} is not yet in the catalog" if idx.nil?
+      add_one_resource(resource, idx+1)
+    end
+  end
+
   def add_resource(*resources)
     resources.each do |resource|
       add_one_resource(resource)
@@ -84,13 +127,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     adjacent(resource, :direction => :in)[0]
   end
 
-  def add_one_resource(resource)
+  def add_one_resource(resource, idx=-1)
     title_key = title_key_for_ref(resource.ref)
     if @resource_table[title_key]
       fail_on_duplicate_type_and_title(resource, title_key)
     end
 
-    add_resource_to_table(resource, title_key)
+    add_resource_to_table(resource, title_key, idx)
     create_resource_aliases(resource)
 
     resource.catalog = self if resource.respond_to?(:catalog=)
@@ -98,9 +141,9 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   end
   private :add_one_resource
 
-  def add_resource_to_table(resource, title_key)
+  def add_resource_to_table(resource, title_key, idx)
     @resource_table[title_key] = resource
-    @resources << title_key
+    @resources.insert(idx, title_key)
   end
   private :add_resource_to_table
 
@@ -124,14 +167,15 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Create an alias for a resource.
   def alias(resource, key)
-    resource.ref =~ /^(.+)\[/
+    ref = resource.ref
+    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
+      return if ref_string == ref
     end
 
     # LAK:NOTE It's important that we directly compare the references,
@@ -142,12 +186,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       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}"
+      msg = "Cannot alias #{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
+    @aliases[ref] ||= []
+    @aliases[ref] << newref
   end
 
   # Apply our catalog to the local host.
@@ -177,10 +221,6 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       transaction.report.as_logging_destination do
         transaction.evaluate
       end
-    rescue Puppet::Error => detail
-      Puppet.log_exception(detail, "Could not apply complete catalog: #{detail}")
-    rescue => 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.
@@ -249,9 +289,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     host_config
   end
 
-  def initialize(name = nil, environment = Puppet::Node::Environment::NONE)
+  def initialize(name = nil, environment = Puppet::Node::Environment::NONE, code_id = nil)
     super()
     @name = name
+    @catalog_uuid = SecureRandom.uuid
+    @catalog_format = 1
+    @metadata = {}
+    @recursive_metadata = {}
     @classes = []
     @resource_table = {}
     @resources = []
@@ -260,6 +304,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     @host_config = true
     @environment_instance = environment
     @environment = environment.to_s
+    @code_id = code_id
 
     @aliases = {}
 
@@ -288,36 +333,54 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # references to the resource instances.
   def remove_resource(*resources)
     resources.each do |resource|
-      title_key = title_key_for_ref(resource.ref)
+      ref = resource.ref
+      title_key = title_key_for_ref(ref)
       @resource_table.delete(title_key)
-      if aliases = @aliases[resource.ref]
+      if aliases = @aliases[ref]
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
-        @aliases.delete(resource.ref)
+        @aliases.delete(ref)
       end
       remove_vertex!(resource) if vertex?(resource)
       @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource)
       @resources.delete(title_key)
-      resource.remove
+      # Only Puppet::Type kind of resources respond to :remove, not Puppet::Resource
+      resource.remove if resource.respond_to?(: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
-    # canonicalizes how we are referring to them.
-    attributes = { :environment => environment_instance }
-    if title
-      res = Puppet::Resource.new(type, title, attributes)
-    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 canonicalizes for us.
-      res = Puppet::Resource.new(nil, type, attributes)
+    # Retain type if it's a type
+    type_name = type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type) ? type.name : type
+    type_name, title = Puppet::Resource.type_and_title(type_name, title)
+    type = type_name if type.is_a?(String)
+    title_key   = [type_name, title.to_s]
+    result = @resource_table[title_key]
+    if result.nil?
+      # an instance has to be created in order to construct the unique key used when
+      # searching for aliases, or when app_management is active and nothing is found in
+      # which case it is needed by the CapabilityFinder.
+      res = nil
+      app_mgnt = Puppet[:app_management]
+      if app_mgnt || !@aliases.empty?
+        res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
+
+        # No need to build the uniqueness key unless there are aliases
+        result = @resource_table[[type_name, res.uniqueness_key].flatten] unless @aliases.empty?
+      end
+
+      if result.nil? && app_mgnt
+        resource_type = res.resource_type
+        if resource_type && resource_type.is_capability?
+          # @todo lutter 2015-03-10: this assumes that it is legal to just
+          # mention a capability resource in code and have it automatically
+          # made available, even if the current component does not require it
+          result = Puppet::Resource::CapabilityFinder.find(environment, code_id, res)
+          add_resource(result) if result
+        end
+      end
     end
-    res.catalog = self
-    title_key      = [res.type, res.title.to_s]
-    uniqueness_key = [res.type, res.uniqueness_key].flatten
-    @resource_table[title_key] || @resource_table[uniqueness_key]
+    result
   end
 
   def resource_refs
@@ -345,14 +408,31 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       result.version = version
     end
 
+    if code_id = data['code_id']
+      result.code_id = code_id
+    end
+
+    if catalog_uuid = data['catalog_uuid']
+      result.catalog_uuid = catalog_uuid
+    end
+
+    result.catalog_format = data['catalog_format'] || 0
+
     if environment = data['environment']
       result.environment = environment
       result.environment_instance = Puppet::Node::Environment.remote(environment.to_sym)
     end
 
     if resources = data['resources']
+      # TODO: The deserializer needs a loader in order to deserialize types defined using the puppet language.
+      json_deserializer = nil
+      if resources.any? { |res| res.has_key?('ext_parameters') }
+        json_deserializer = Puppet::Pops::Serialization::Deserializer.new(
+            Puppet::Pops::Serialization::JSON::Reader.new([]),
+            Puppet::Pops::Loaders.catalog_loader)
+      end
       result.add_resource(*resources.collect do |res|
-        Puppet::Resource.from_data_hash(res)
+        Puppet::Resource.from_data_hash(res, json_deserializer)
       end)
     end
 
@@ -377,19 +457,55 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       result.add_class(*classes)
     end
 
+    if metadata = data['metadata']
+      result.metadata = metadata.inject({}) { |h, (k, v)| h[k] = Puppet::FileServing::Metadata.from_data_hash(v); h }
+    end
+
+    if recursive_metadata = data['recursive_metadata']
+      result.recursive_metadata = recursive_metadata.inject({}) do |h, (title, source_to_meta_hash)|
+        h[title] = source_to_meta_hash.inject({}) do |inner_h, (source, metas)|
+          inner_h[source] = metas.map {|meta| Puppet::FileServing::Metadata.from_data_hash(meta)}
+          inner_h
+        end
+        h
+      end
+    end
+
     result
   end
 
   def to_data_hash
+    metadata_hash = metadata.inject({}) { |h, (k, v)| h[k] = v.to_data_hash; h }
+    recursive_metadata_hash = recursive_metadata.inject({}) do |h, (title, source_to_meta_hash)|
+      h[title] = source_to_meta_hash.inject({}) do |inner_h, (source, metas)|
+        inner_h[source] = metas.map {|meta| meta.to_data_hash}
+        inner_h
+      end
+      h
+    end
+
+    resources = if @resources.empty?
+        []
+      elsif environment_instance.rich_data?
+        json_serializer = Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON::Writer.new(''))
+        @resources.collect { |v| @resource_table[v].to_data_hash(json_serializer) }
+      else
+        @resources.collect { |v| @resource_table[v].to_data_hash }
+      end
+
     {
       'tags'      => tags,
       'name'      => name,
       'version'   => version,
-      'environment' => environment.to_s,
-      'resources' => @resources.collect { |v| @resource_table[v].to_data_hash },
+      'code_id'   => code_id,
+      'catalog_uuid' => catalog_uuid,
+      'catalog_format' => catalog_format,
+      'environment'  => environment.to_s,
+      'resources' => resources,
       'edges'     => edges.   collect { |e| e.to_data_hash },
-      'classes'   => classes
-    }
+      'classes'   => classes,
+    }.merge(metadata_hash.empty? ? {} : {'metadata' => metadata_hash})
+     .merge(recursive_metadata_hash.empty? ? {} : {'recursive_metadata' => recursive_metadata_hash})
   end
 
   # Convert our catalog into a RAL catalog.
@@ -422,7 +538,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Store the classes in the classfile.
   def write_class_file
-    ::File.open(Puppet[:classfile], "w") do |f|
+    # classfile paths may contain UTF-8
+    # https://docs.puppet.com/puppet/latest/reference/configuration.html#classfile
+    classfile = Puppet.settings.setting(:classfile)
+    Puppet::FileSystem.open(classfile.value, classfile.mode.to_i(8), "w:UTF-8") do |f|
       f.puts classes.join("\n")
     end
   rescue => detail
@@ -431,7 +550,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Store the list of resources we manage
   def write_resource_file
-    ::File.open(Puppet[:resourcefile], "w") do |f|
+    # resourcefile contains resources that may be UTF-8 names
+    # https://docs.puppet.com/puppet/latest/reference/configuration.html#resourcefile
+    resourcefile = Puppet.settings.setting(:resourcefile)
+    Puppet::FileSystem.open(resourcefile.value, resourcefile.mode.to_i(8), "w:UTF-8") do |f|
       to_print = resources.map do |resource|
         next unless resource.managed?
         if resource.name_var
@@ -500,6 +622,11 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     result = self.class.new(self.name, self.environment_instance)
 
     result.version = self.version
+    result.code_id = self.code_id
+    result.catalog_uuid = self.catalog_uuid
+    result.catalog_format = self.catalog_format
+    result.metadata = self.metadata
+    result.recursive_metadata = self.recursive_metadata
 
     map = {}
     resources.each do |resource|

data/lib/puppet/resource/status.rb

@@ -12,9 +12,9 @@ module Puppet
     #
     # @api private
     class Status
+      include Puppet::Util::PsychSupport
       include Puppet::Util::Tagging
       include Puppet::Network::FormatSupport
-      include Puppet::Util::PsychSupport
 
       # @!attribute [rw] file
       #   @return [String] The file where `@real_resource` was defined.
@@ -30,7 +30,7 @@ module Puppet
       attr_accessor :evaluation_time
 
       # Boolean status types set while evaluating `@real_resource`.
-      STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled]
+      STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled, :corrective_change]
       attr_accessor *STATES
 
       # @!attribute [r] source_description
@@ -83,6 +83,19 @@ module Puppet
       #     while evaluating `@real_resource`.
       attr_reader :events
 
+      # @!attribute [r] corrective_change
+      #   @return [Boolean] true if the resource contained a corrective change.
+      attr_reader :corrective_change
+
+      # @!attribute [rw] failed_dependencies
+      #   @return [Array<Puppet::Resource>] A cache of all
+      #   dependencies of this resource that failed to apply.
+      attr_accessor :failed_dependencies
+
+      def dependency_failed?
+        failed_dependencies && !failed_dependencies.empty?
+      end
+
       # A list of instance variables that should be serialized with this object
       # when converted to YAML.
       YAML_ATTRIBUTES = %w{@resource @file @line @evaluation_time @change_count
@@ -121,6 +134,9 @@ module Puppet
           @out_of_sync_count += 1
           @out_of_sync = true
         end
+        if event.corrective_change
+          @corrective_change = true
+        end
       end
 
       def failed_because(detail)
@@ -144,6 +160,7 @@ module Puppet
         @out_of_sync = false
         @skipped = false
         @failed = false
+        @corrective_change = false
 
         @file = resource.file
         @line = resource.line
@@ -172,9 +189,16 @@ module Puppet
         @changed = data['changed']
         @skipped = data['skipped']
         @failed = data['failed']
-
+        @corrective_change = data['corrective_change']
         @events = data['events'].map do |event|
-          Puppet::Transaction::Event.from_data_hash(event)
+          # in YAML (for reports) we serialize this as an object, but
+          # in PSON it becomes a hash. Depending on where we came from
+          # we might not need to deserialize it.
+          if event.class == Puppet::Transaction::Event
+            event
+          else
+            Puppet::Transaction::Event.from_data_hash(event)
+          end
         end
       end
 
@@ -187,7 +211,7 @@ module Puppet
           'resource_type' => @resource_type,
           'containment_path' => @containment_path,
           'evaluation_time' => @evaluation_time,
-          'tags' => @tags,
+          'tags' => @tags.to_a,
           'time' => @time.iso8601(9),
           'failed' => @failed,
           'changed' => @changed,
@@ -196,6 +220,7 @@ module Puppet
           'change_count' => @change_count,
           'out_of_sync_count' => @out_of_sync_count,
           'events' => @events,
+          'corrective_change' => @corrective_change,
         }
       end