puppet 5.3.4 → 6.29.0

data/lib/puppet/reference/metaparameter.rb

@@ -19,9 +19,7 @@ etc.), prevent Puppet from making changes (`noop`), and change logging verbosity
       params << param
     }
 
-    params.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.each { |param|
+    params.sort_by(&:to_s).each { |param|
       str << markdown_header(param.to_s, 3)
       str << scrub(Puppet::Type.metaparamdoc(param))
       str << "\n\n"

data/lib/puppet/reference/providers.rb

@@ -15,7 +15,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
   # Throw some facts in there, so we know where the report is from.
   ["Ruby Version", "Puppet Version", "Operating System", "Operating System Release"].each do |label|
     name = label.gsub(/\s+/, '')
-    value = Facter.value(name)
+    value = Puppet.runtime[:facter].value(name)
     ret << option(label, value)
   end
   ret << "\n"
@@ -32,19 +32,18 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
     table_data = {}
 
-    functional = false
     notes = []
     default = type.defaultprovider ? type.defaultprovider.name : 'none'
-    type.providers.sort { |a,b| a.to_s <=> b.to_s }.each do |pname|
+    type.providers.sort_by(&:to_s).each do |pname|
       data = []
       table_data[pname] = data
       provider = type.provider(pname)
 
       # Add the suitability note
-      if missing = provider.suitable?(false) and missing.empty?
+      missing = provider.suitable?(false)
+      if missing && missing.empty?
         data << "*X*"
         suit = true
-        functional = true
       else
         data << "[#{count}]_" # A pointer to the appropriate footnote
         suit = false
@@ -62,7 +61,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
               if Puppet.settings.valid?(name)
                 details << _("  - Setting %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Puppet.settings.value(name).inspect, facts: facts.join(", ") }
               else
-                details << _("  - Fact %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Facter.value(name).inspect, facts: facts.join(", ") }
+                details << _("  - Fact %{name} (currently %{value}) not in list %{facts}\n") % { name: name, value: Puppet.runtime[:facter].value(name).inspect, facts: facts.join(", ") }
               end
             end
           when :true
@@ -90,7 +89,7 @@ providers = Puppet::Util::Reference.newreference :providers, :title => "Provider
 
     ret << markdown_header(type.name.to_s + "_", 2)
 
-    ret << "[#{type.name}](https://docs.puppetlabs.com/puppet/latest/reference/type.html##{type.name})\n\n"
+    ret << "[#{type.name}](https://puppet.com/docs/puppet/latest/type.html##{type.name})\n\n"
     ret << option("Default provider", default)
     ret << doctable(headers, table_data)
 

data/lib/puppet/reference/report.rb

@@ -14,7 +14,7 @@ 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.
 
-See [About Reporting](https://docs.puppetlabs.com/puppet/latest/reference/reporting_about.html)
+See [About Reporting](https://puppet.com/docs/puppet/latest/reporting_about.html)
 for more details.
 
 "

data/lib/puppet/reference/type.rb

@@ -47,31 +47,28 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
   Resource types define features they can use, and providers can be tested to see
   which features they provide.
 
-    }
+  }
 
-    types.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.each { |name,type|
+  types.sort_by(&:to_s).each { |name,type|
 
-      str << "
+    str << "
 
 ----------------
 
 "
 
-  str << markdown_header(name, 3)
-  str << scrub(type.doc) + "\n\n"
+    str << markdown_header(name, 3)
+    str << scrub(type.doc) + "\n\n"
 
-  # Handle the feature docs.
-  if featuredocs = type.featuredocs
-    str << markdown_header("Features", 4)
-    str << featuredocs
+    # Handle the feature docs.
+    featuredocs = type.featuredocs
+    if featuredocs
+      str << markdown_header("Features", 4)
+      str << featuredocs
     end
 
     docs = {}
-    type.validproperties.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.reject { |sname|
+    type.validproperties.sort_by(&:to_s).reject { |sname|
       property = type.propertybyname(sname)
       property.nodoc
     }.each { |sname|
@@ -79,8 +76,8 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
 
       raise _("Could not retrieve property %{sname} on type %{type_name}") % { sname: sname, type_name: type.name } unless property
 
-      doc = nil
-      unless doc = property.doc
+      doc = property.doc
+      unless doc
         $stderr.puts _("No docs for %{type}[%{sname}]") % { type: type, sname: sname }
         next
       end
@@ -92,9 +89,7 @@ Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types a
     }
 
     str << markdown_header("Parameters", 4) + "\n"
-    type.parameters.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.each { |type_name, param|
+    type.parameters.sort_by(&:to_s).each { |type_name, param|
       docs[type_name] = scrub(type.paramdoc(type_name))
     }
 

data/lib/puppet/relationship.rb

@@ -19,12 +19,8 @@ class Puppet::Relationship
     target = data['target']
 
     args = {}
-    if event = data["event"]
-      args[:event] = :"#{event}"
-    end
-    if callback = data["callback"]
-      args[:callback] = :"#{callback}"
-    end
+    args[:event] = :"#{data['event']}" if data["event"]
+    args[:callback] = :"#{data['callback']}" if data["callback"]
 
     new(source, target, args)
   end
@@ -40,9 +36,8 @@ class Puppet::Relationship
 
     options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
     [:callback, :event].each do |option|
-      if value = options[option]
-        send(option.to_s + "=", value)
-      end
+      value = options[option]
+      send(option.to_s + "=", value) if value
     end
   end
 

data/lib/puppet/reports/http.rb

@@ -20,18 +20,25 @@ Puppet::Reports.register_report(:http) do
     # (Puppet::Network::HTTP) but is used by Puppet Server's http client
     # (Puppet::Server::HttpClient) to track metrics on the request made to the
     # `reporturl` to store a report.
-    options = { :metric_id => [:puppet, :report, :http] }
+    options = {
+      :metric_id => [:puppet, :report, :http],
+      :include_system_store => Puppet[:report_include_system_store],
+    }
+
+    # Puppet's http client implementation accepts userinfo in the URL
+    # but puppetserver's does not. So pass credentials explicitly.
     if url.user && url.password
       options[:basic_auth] = {
-        :user => url.user,
-        :password => url.password
+        user: url.user,
+        password: url.password
       }
     end
-    use_ssl = url.scheme == 'https'
-    conn = Puppet::Network::HttpPool.http_instance(url.host, url.port, use_ssl)
-    response = conn.post(url.path, self.to_yaml, headers, options)
-    unless response.kind_of?(Net::HTTPSuccess)
-      Puppet.err _("Unable to submit report to %{url} [%{code}] %{message}") % { url: Puppet[:reporturl].to_s, code: response.code, message: response.msg }
+
+    client = Puppet.runtime[:http]
+    client.post(url, self.to_yaml, headers: headers, options: options) do |response|
+      unless response.success?
+        Puppet.err _("Unable to submit report to %{url} [%{code}] %{message}") % { url: Puppet[:reporturl].to_s, code: response.code, message: response.reason }
+      end
     end
   end
 end

data/lib/puppet/reports/store.rb

@@ -32,7 +32,7 @@ Puppet::Reports.register_report(:store) do
     file = File.join(dir, name)
 
     begin
-      Puppet::Util.replace_file(file, 0640) do |fh|
+      Puppet::FileSystem.replace_file(file, 0640) do |fh|
         fh.print to_yaml
       end
     rescue => detail

data/lib/puppet/reports.rb

@@ -73,8 +73,8 @@ class Puppet::Reports
     docs = ""
 
     # Use this method so they all get loaded
-    instance_loader(:report).loadall
-    loaded_instances(:report).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
+    instance_loader(:report).loadall(Puppet.lookup(:current_environment))
+    loaded_instances(:report).sort_by(&:to_s).each do |name|
       mod = self.report(name)
       docs << "#{name}\n#{"-" * name.to_s.length}\n"
 
@@ -87,7 +87,7 @@ class Puppet::Reports
   # Lists each of the reports.
   # @api private
   def self.reports
-    instance_loader(:report).loadall
+    instance_loader(:report).loadall(Puppet.lookup(:current_environment))
     loaded_instances(:report)
   end
 end

data/lib/puppet/resource/capability_finder.rb

@@ -7,7 +7,7 @@
 
 require 'net/http'
 require 'cgi'
-require 'json'
+require 'puppet/util/json'
 
 # @api private
 module Puppet::Resource::CapabilityFinder
@@ -38,14 +38,17 @@ module Puppet::Resource::CapabilityFinder
       Puppet.debug "Could not find capability resource #{cap} in PuppetDB"
     elsif resources.size == 1
       resource_hash = resources.first
-    elsif code_id_resource = disambiguate_by_code_id(environment, code_id, cap)
-      resource_hash = code_id_resource
     else
-      #TRANSLATOR PuppetDB is a product name and should not be translated
-      message = _("Unexpected response from PuppetDB when looking up %{capability}:") % { capability: cap }
-      message += "\n" + _("expected exactly one resource but got %{count};") % { count: resources.size }
-      message += "\n" + _("returned data is:\n%{resources}") % { resources: resources.inspect }
-      raise Puppet::DevError, message
+      code_id_resource = disambiguate_by_code_id(environment, code_id, cap)
+      if code_id_resource
+        resource_hash = code_id_resource
+      else
+        #TRANSLATOR PuppetDB is a product name and should not be translated
+        message = _("Unexpected response from PuppetDB when looking up %{capability}:") % { capability: cap }
+        message += "\n" + _("expected exactly one resource but got %{count};") % { count: resources.size }
+        message += "\n" + _("returned data is:\n%{resources}") % { resources: resources.inspect }
+        raise Puppet::DevError, message
+      end
     end
 
     if resource_hash
@@ -92,11 +95,11 @@ module Puppet::Resource::CapabilityFinder
         response = Puppet::Util::Puppetdb::Http.action(url) do |conn, uri|
           conn.get(uri, { 'Accept' => 'application/json'})
         end
-        JSON.parse(response.body)
+        Puppet::Util::Json.load(response.body)
       end
 
       # The format of the response body is documented at
-      #   https://docs.puppetlabs.com/puppetdb/3.0/api/query/v4/resources.html#response-format
+      #   https://puppet.com/docs/puppetdb/3.0/api/query/v4/resources.html#response-format
       unless result.is_a?(Array)
         #TRANSLATOR PuppetDB is a product name and should not be translated
         raise Puppet::DevError, _("Unexpected response from PuppetDB when looking up %{capability}: expected an Array but got %{result}") %
@@ -104,14 +107,12 @@ module Puppet::Resource::CapabilityFinder
       end
 
       result
-    rescue JSON::JSONError => e
+    rescue Puppet::Util::Json::ParseError => e
       #TRANSLATOR PuppetDB is a product name and should not be translated
       raise Puppet::DevError, _("Invalid JSON from PuppetDB when looking up %{capability}\n%{detail}") % { capability: cap, detail: e }
     end
   end
 
-  private
-
   # Find a distinct copy of the given capability resource by searching for only
   # resources matching the given code_id. Returns `nil` if no code_id is
   # supplied or if there isn't exactly one matching resource.
@@ -132,6 +133,7 @@ module Puppet::Resource::CapabilityFinder
       end
     end
   end
+  private_class_method :disambiguate_by_code_id
 
   def self.instantiate_resource(resource_hash)
     real_type = resource_hash['type']
@@ -139,7 +141,8 @@ module Puppet::Resource::CapabilityFinder
     real_type.parameters.each do |param|
       param = param.to_s
       next if param == 'name'
-      if value = resource_hash['parameters'][param]
+      value = resource_hash['parameters'][param]
+      if value
         resource[param] = value
       else
         Puppet.debug "No capability value for #{resource}->#{param}"
@@ -147,4 +150,5 @@ module Puppet::Resource::CapabilityFinder
     end
     return resource
   end
+  private_class_method :instantiate_resource
 end

data/lib/puppet/resource/catalog.rb

@@ -197,7 +197,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     # 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]
+    existing = @resource_table[newref]
+    if existing
       return if existing == resource
       resource_declaration = Puppet::Util::Errors.error_location(resource.file, resource.line)
       msg = if resource_declaration.empty?
@@ -235,7 +236,10 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
     begin
       transaction.report.as_logging_destination do
-        transaction.evaluate
+        transaction_evaluate_time = Puppet::Util.thinmark do
+          transaction.evaluate
+        end
+        transaction.report.add_times(:transaction_evaluation, transaction_evaluate_time)
       end
     ensure
       # Don't try to store state unless we're a host config
@@ -283,10 +287,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
 
   # Create a new resource and register it in the catalog.
   def create_resource(type, options)
-    unless klass = Puppet::Type.type(type)
+    klass = Puppet::Type.type(type)
+    unless klass
       raise ArgumentError, _("Unknown resource type %{type}") % { type: type }
     end
-    return unless resource = klass.new(options)
+    resource = klass.new(options)
+    return unless resource
 
     add_resource(resource)
     resource
@@ -309,7 +315,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     super()
     @name = name
     @catalog_uuid = SecureRandom.uuid
-    @catalog_format = 1
+    @catalog_format = 2
     @metadata = {}
     @recursive_metadata = {}
     @classes = []
@@ -339,7 +345,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     Puppet::Type.type(:schedule).mkdefaultschedules.each { |res| add_resource(res) unless resource(res.ref) }
 
     # And filebuckets
-    if bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
+    bucket = Puppet::Type.type(:filebucket).mkdefaultbucket
+    if bucket
       add_resource(bucket) unless resource(bucket.ref)
     end
   end
@@ -352,7 +359,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       ref = resource.ref
       title_key = title_key_for_ref(ref)
       @resource_table.delete(title_key)
-      if aliases = @aliases[ref]
+      aliases = @aliases[ref]
+      if aliases
         aliases.each { |res_alias| @resource_table.delete(res_alias) }
         @aliases.delete(ref)
       end
@@ -374,8 +382,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     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.
+      # searching for aliases, or nothing is found as it is needed by the CapabilityFinder.
       res = Puppet::Resource.new(type, title, { :environment => @environment_instance })
 
       # Must check with uniqueness key because of aliases or if resource transforms title in title
@@ -413,45 +420,36 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   def self.from_data_hash(data)
     result = new(data['name'], Puppet::Node::Environment::NONE)
 
-    if tags = data['tags']
-      result.tag(*tags)
-    end
-
-    if version = data['version']
-      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.tag(*data['tags']) if data['tags'] 
+    result.version = data['version'] if data['version']
+    result.code_id = data['code_id'] if data['code_id']
+    result.catalog_uuid = data['catalog_uuid'] if data['catalog_uuid']
     result.catalog_format = data['catalog_format'] || 0
 
-    if environment = data['environment']
+    environment = data['environment']
+    if environment
       result.environment = environment
       result.environment_instance = Puppet::Node::Environment.remote(environment.to_sym)
     end
 
-    if resources = data['resources']
-      result.add_resource(*resources.collect do |res|
+    result.add_resource(
+      *data['resources'].collect do |res|
         Puppet::Resource.from_data_hash(res)
-      end)
-    end
+      end
+    ) if data['resources']
 
-    if edges = data['edges']
-      edges.each do |edge_hash|
+    if data['edges']
+      data['edges'].each do |edge_hash|
         edge = Puppet::Relationship.from_data_hash(edge_hash)
-        unless source = result.resource(edge.source)
+        source = result.resource(edge.source)
+        unless source
           raise ArgumentError, _("Could not intern from data: Could not find relationship source %{source} for %{target}") %
               { source: edge.source.inspect, target: edge.target.to_s }
         end
         edge.source = source
 
-        unless target = result.resource(edge.target)
+        target = result.resource(edge.target)
+        unless target
           raise ArgumentError, _("Could not intern from data: Could not find relationship target %{target} for %{source}") %
               { target: edge.target.inspect, source: edge.source.to_s }
         end
@@ -461,15 +459,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       end
     end
 
-    if classes = data['classes']
-      result.add_class(*classes)
-    end
+    result.add_class(*data['classes']) if data['classes']
 
-    if metadata = data['metadata']
-      result.metadata = metadata.inject({}) { |h, (k, v)| h[k] = Puppet::FileServing::Metadata.from_data_hash(v); h }
-    end
+    result.metadata = data['metadata'].inject({}) { |h, (k, v)| h[k] = Puppet::FileServing::Metadata.from_data_hash(v); h } if data['metadata']
 
-    if recursive_metadata = data['recursive_metadata']
+    recursive_metadata = data['recursive_metadata']
+    if 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)}
@@ -539,7 +534,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Store the classes in the classfile.
   def write_class_file
     # classfile paths may contain UTF-8
-    # https://docs.puppet.com/puppet/latest/reference/configuration.html#classfile
+    # https://puppet.com/docs/puppet/latest/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")
@@ -551,16 +546,12 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Store the list of resources we manage
   def write_resource_file
     # resourcefile contains resources that may be UTF-8 names
-    # https://docs.puppet.com/puppet/latest/reference/configuration.html#resourcefile
+    # https://puppet.com/docs/puppet/latest/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
-          "#{resource.type}[#{resource[resource.name_var]}]"
-        else
-          "#{resource.ref.downcase}"
-        end
+        "#{resource.ref.downcase}"
       end.compact
       f.puts to_print.join("\n")
     end
@@ -579,23 +570,14 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   private
 
   def prioritizer
-    @prioritizer ||= case Puppet[:ordering]
-                     when "title-hash"
-                       Puppet::Graph::TitleHashPrioritizer.new
-                     when "manifest"
-                       Puppet::Graph::SequentialPrioritizer.new
-                     when "random"
-                       Puppet::Graph::RandomPrioritizer.new
-                     else
-                       raise Puppet::DevError, _("Unknown ordering type %{ordering}") % { ordering: Puppet[:ordering] }
-                     end
+    @prioritizer = Puppet::Graph::SequentialPrioritizer.new
   end
 
   def create_transaction(options)
     transaction = Puppet::Transaction.new(self, options[:report], prioritizer)
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
-    transaction.for_network_device = options[:network_device]
+    transaction.for_network_device = Puppet.lookup(:network_device) { nil } || options[:network_device]
 
     transaction
   end
@@ -603,7 +585,8 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
   # Verify that the given resource isn't declared elsewhere.
   def fail_on_duplicate_type_and_title(resource, title_key)
     # Short-circuit the common case,
-    return unless existing_resource = @resource_table[title_key]
+    existing_resource = @resource_table[title_key]
+    return unless existing_resource
 
     # If we've gotten this far, it's a real conflict
     error_location_str = Puppet::Util::Errors.error_location(existing_resource.file, existing_resource.line)
@@ -648,7 +631,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       result.add_resource newres
     end
 
-    message = convert.to_s.gsub "_", " "
+    message = convert.to_s.tr "_", " "
     edges.each do |edge|
       # Skip edges between virtual resources.
       next if virtual_not_exported?(edge.source)
@@ -657,11 +640,13 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
       next if virtual_not_exported?(edge.target)
       next if block_given? and yield edge.target
 
-      unless source = map[edge.source.ref]
+      source = map[edge.source.ref]
+      unless source
         raise Puppet::DevError, _("Could not find resource %{resource} when converting %{message} resources") % { resource: edge.source.ref, message: message }
       end
 
-      unless target = map[edge.target.ref]
+      target = map[edge.target.ref]
+      unless target
         raise Puppet::DevError, _("Could not find resource %{resource} when converting %{message} resources") % { resource: edge.target.ref, message: message }
       end
 
@@ -671,7 +656,7 @@ class Puppet::Resource::Catalog < Puppet::Graph::SimpleGraph
     map.clear
 
     result.add_class(*self.classes)
-    result.tag(*self.tags)
+    result.merge_tags_from(self)
 
     result
   end

data/lib/puppet/resource/status.rb

@@ -31,7 +31,7 @@ module Puppet
 
       # Boolean status types set while evaluating `@real_resource`.
       STATES = [:skipped, :failed, :failed_to_restart, :restarted, :changed, :out_of_sync, :scheduled, :corrective_change]
-      attr_accessor *STATES
+      attr_accessor(*STATES)
 
       # @!attribute [r] source_description
       #   @return [String] The textual description of the path to `@real_resource`
@@ -74,6 +74,10 @@ module Puppet
       #   @return [String] The class name of `@real_resource`
       attr_reader :resource_type
 
+      # @!attribute [rw] provider_used
+      #   @return [String] The class name of the provider used for the resource
+      attr_accessor :provider_used
+
       # @!attribute [r] title
       #   @return [String] The title of `@real_resource`
       attr_reader :title
@@ -144,7 +148,6 @@ module Puppet
       # Puppet::Transaction::Event failure with the given message.
       # @param message [String] the reason for a status failure
       def fail_with_event(message)
-        failed = true
         add_event(@real_resource.event(:name => :resource_error, :status => "failure", :message => message))
       end
 
@@ -164,15 +167,17 @@ module Puppet
         @file = resource.file
         @line = resource.line
 
-        tag(*resource.tags)
+        merge_tags_from(resource)
         @time = Time.now
         @events = []
         @resource_type = resource.type.to_s.capitalize
+        @provider_used = resource.provider.class.name.to_s unless resource.provider.nil?
         @title = resource.title
       end
 
       def initialize_from_hash(data)
         @resource_type = data['resource_type']
+        @provider_used = data['provider_used']
         @title = data['title']
         @resource = data['resource']
         @containment_path = data['containment_path']
@@ -188,6 +193,7 @@ module Puppet
         @changed = data['changed']
         @skipped = data['skipped']
         @failed = data['failed']
+        @failed_to_restart = data['failed_to_restart']
         @corrective_change = data['corrective_change']
         @events = data['events'].map do |event|
           # Older versions contain tags that causes Psych to create instances directly
@@ -202,11 +208,13 @@ module Puppet
           'line' => @line,
           'resource' => @resource,
           'resource_type' => @resource_type,
+          'provider_used' => @provider_used,
           'containment_path' => @containment_path,
           'evaluation_time' => @evaluation_time,
           'tags' => @tags.to_a,
           'time' => @time.iso8601(9),
           'failed' => @failed,
+          'failed_to_restart' => self.failed_to_restart?,
           'changed' => @changed,
           'out_of_sync' => @out_of_sync,
           'skipped' => @skipped,