diff --git a/lib/facter/docker.rb b/lib/facter/docker.rb
index 41f9438..f01749f 100644
--- a/lib/facter/docker.rb
+++ b/lib/facter/docker.rb
@@ -1,135 +1,135 @@
 # frozen_string_literal: true
 
 require 'facter'
 require 'json'
 
 Facter.add(:docker_systemroot) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('SystemRoot')
   end
 end
 
 Facter.add(:docker_program_files_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('ProgramFiles')
   end
 end
 
 Facter.add(:docker_program_data_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('ProgramData')
   end
 end
 
 Facter.add(:docker_user_temp_path) do
   confine osfamily: :windows
   setcode do
     Puppet::Util.get_env('TEMP')
   end
 end
 
 docker_command = if Facter.value(:kernel) == 'windows'
                    'powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -c docker'
                  else
                    'docker'
                  end
 
 def interfaces
   Facter.value(:interfaces).split(',')
 end
 
 Facter.add(:docker_client_version) do
   setcode do
     docker_version = Facter.value(:docker_version)
     if docker_version
       if !docker_version['Client'].nil?
         docker_version['Client']['Version']
       else
         docker_version['Version']
       end
     end
   end
 end
 
 Facter.add(:docker_server_version) do
   setcode do
     docker_version = Facter.value(:docker_version)
     if docker_version && !docker_version['Server'].nil? && docker_version['Server'].is_a?(Hash)
       docker_version['Server']['Version']
     else
       nil
     end
   end
 end
 
 Facter.add(:docker_version) do
   setcode do
     if Facter::Core::Execution.which('docker')
       value = Facter::Core::Execution.execute(
-        "#{docker_command} version --format '{{json .}}'", time_limit: 90
+        "#{docker_command} version --format '{{json .}}'", timeout: 90
       )
       val = JSON.parse(value)
     end
     val
   end
 end
 
 Facter.add(:docker_worker_join_token) do
   setcode do
     if Facter::Core::Execution.which('docker')
       val = Facter::Core::Execution.execute(
-        "#{docker_command} swarm join-token worker -q", time_limit: 90
+        "#{docker_command} swarm join-token worker -q", timeout: 90
       )
     end
     val
   end
 end
 
 Facter.add(:docker_manager_join_token) do
   setcode do
     if Facter::Core::Execution.which('docker')
       val = Facter::Core::Execution.execute(
-        "#{docker_command} swarm join-token manager -q", time_limit: 90
+        "#{docker_command} swarm join-token manager -q", timeout: 90
       )
     end
     val
   end
 end
 
 Facter.add(:docker) do
   setcode do
     docker_version = Facter.value(:docker_client_version)
     if docker_version&.match?(%r{1[0-9][0-2]?[.]\w+})
       if Facter::Core::Execution.which('docker')
         docker_json_str = Facter::Core::Execution.execute(
-          "#{docker_command} info --format '{{json .}}'", time_limit: 90
+          "#{docker_command} info --format '{{json .}}'", timeout: 90
         )
         begin
           docker = JSON.parse(docker_json_str)
           docker['network'] = {}
 
           docker['network']['managed_interfaces'] = {}
-          network_list = Facter::Core::Execution.execute("#{docker_command} network ls | tail -n +2", time_limit: 90)
+          network_list = Facter::Core::Execution.execute("#{docker_command} network ls | tail -n +2", timeout: 90)
           docker_network_names = []
           network_list.each_line { |line| docker_network_names.push line.split[1] }
           docker_network_ids = []
           network_list.each_line { |line| docker_network_ids.push line.split[0] }
           docker_network_names.each do |network|
-            inspect = JSON.parse(Facter::Core::Execution.execute("#{docker_command} network inspect #{network}", time_limit: 90))
+            inspect = JSON.parse(Facter::Core::Execution.execute("#{docker_command} network inspect #{network}", timeout: 90))
             docker['network'][network] = inspect[0]
             network_id = docker['network'][network]['Id'][0..11]
             interfaces.each do |iface|
               docker['network']['managed_interfaces'][iface] = network if %r{#{network_id}}.match?(iface)
             end
           end
           docker
         rescue JSON::ParserError
           nil
         end
       end
     end
   end
 end
diff --git a/spec/unit/lib/facter/docker_spec.rb b/spec/unit/lib/facter/docker_spec.rb
index a3ffbb0..88415df 100644
--- a/spec/unit/lib/facter/docker_spec.rb
+++ b/spec/unit/lib/facter/docker_spec.rb
@@ -1,132 +1,132 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 require 'json'
 
 describe 'Facter::Util::Fact' do
   before :each do
     Facter.clear
     allow(Facter::Core::Execution).to receive(:which).and_call_original
     allow(Facter::Core::Execution).to receive(:execute).and_call_original
 
     if Facter.value(:kernel) == 'windows'
       docker_command = 'powershell -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass -c docker'
       allow(Facter::Core::Execution).to receive(:which).with('dhcpcd').and_return('C:\Windows\dhcpd.exe')
       allow(Facter::Core::Execution).to receive(:which).with('route').and_return('C:\Windows\System32\ROUTE.EXE')
       allow(Facter::Core::Execution).to receive(:which).with('docker').and_return('C:\Program Files\Docker\docker.exe')
     else
       docker_command = 'docker'
       allow(Facter::Core::Execution).to receive(:which).with('route').and_return('/usr/bin/route')
       allow(Facter::Core::Execution).to receive(:which).with('dhcpcd').and_return('/usr/bin/dhcpd')
       allow(Facter::Core::Execution).to receive(:which).with('docker').and_return('/usr/bin/docker')
     end
     docker_info = File.read(fixtures('facts', 'docker_info'))
-    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} info --format '{{json .}}'", time_limit: 90).and_return(docker_info)
+    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} info --format '{{json .}}'", timeout: 90).and_return(docker_info)
     processors = File.read(fixtures('facts', 'processors'))
     allow(Facter.fact(:processors)).to receive(:value).and_return(JSON.parse(processors))
     docker_version = File.read(fixtures('facts', 'docker_version'))
-    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} version --format '{{json .}}'", time_limit: 90).and_return(docker_version)
+    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} version --format '{{json .}}'", timeout: 90).and_return(docker_version)
     docker_network_list = File.read(fixtures('facts', 'docker_network_list'))
-    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} network ls | tail -n +2", time_limit: 90).and_return(docker_network_list)
+    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} network ls | tail -n +2", timeout: 90).and_return(docker_network_list)
     docker_network_names = []
     docker_network_list.each_line { |line| docker_network_names.push line.split[1] }
     docker_network_names.each do |network|
       inspect = File.read(fixtures('facts', "docker_network_inspect_#{network}"))
-      allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} network inspect #{network}", time_limit: 90).and_return(inspect)
+      allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} network inspect #{network}", timeout: 90).and_return(inspect)
     end
     docker_worker_token = File.read(fixtures('facts', 'docker_swarm_worker_token'))
-    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} swarm join-token worker -q", time_limit: 90).and_return(docker_worker_token.chomp)
+    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} swarm join-token worker -q", timeout: 90).and_return(docker_worker_token.chomp)
     docker_manager_token = File.read(fixtures('facts', 'docker_swarm_manager_token'))
-    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} swarm join-token manager -q", time_limit: 90).and_return(docker_manager_token.chomp)
+    allow(Facter::Core::Execution).to receive(:execute).with("#{docker_command} swarm join-token manager -q", timeout: 90).and_return(docker_manager_token.chomp)
   end
   after(:each) { Facter.clear }
 
   describe 'docker fact with composer network' do
     before :each do
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-c5810f1e3113,docker0,eth0,lo')
     end
     it do
       fact = File.read(fixtures('facts', 'facts_with_compose'))
       fact = JSON.parse(fact.to_json, quirks_mode: true)
       facts = eval(fact) # rubocop:disable Security/Eval
       expect(Facter.fact(:docker).value).to include(
         'network' => facts['network'],
       )
     end
   end
 
   describe 'docker fact without composer network' do
     before :each do
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       fact = File.read(fixtures('facts', 'facts_without_compose')).chomp
       fact_json = fact.to_json
       facts = JSON.parse(fact_json, quirks_mode: true)
       facts = eval(facts) # rubocop:disable Security/Eval
 
       expect(Facter.fact(:docker).value).to include(
         'network' => facts['network'],
       )
     end
   end
 
   describe 'docker client version' do
     before(:each) do
       docker_version = File.read(fixtures('facts', 'docker_version'))
       allow(Facter.fact(:docker_version)).to receive(:value).and_return(JSON.parse(docker_version))
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       expect(Facter.fact(:docker_client_version).value).to eq(
         '17.03.1-ce-client',
       )
     end
   end
 
   describe 'docker server version' do
     before(:each) do
       docker_version = File.read(fixtures('facts', 'docker_version'))
       allow(Facter.fact(:docker_version)).to receive(:value).and_return(JSON.parse(docker_version))
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       expect(Facter.fact(:docker_server_version).value).to eq(
         '17.03.1-ce-server',
       )
     end
   end
 
   describe 'docker info' do
     before :each do
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it 'has valid entries' do
       expect(Facter.fact(:docker).value).to include(
         'Architecture' => 'x86_64',
       )
     end
   end
 
   describe 'docker swarm worker join-token' do
     before :each do
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       expect(Facter.fact(:docker_worker_join_token).value).to eq(
         'SWMTKN-1-2m7ekt7511j5kgrc6seyrewpdxv47ksz1sdg7iybzhuug6nmws-0jh0syqeoj3tlr81p165ydfkm',
       )
     end
   end
 
   describe 'docker swarm manager join-token' do
     before :each do
       allow(Facter.fact(:interfaces)).to receive(:value).and_return('br-19a6ebf6f5a5,docker0,eth0,lo')
     end
     it do
       expect(Facter.fact(:docker_manager_join_token).value).to eq(
         'SWMTKN-1-2m7ekt7511j5kgrc6seyrewpdxv47ksz1sdg7iybzhuug6nmws-8gh1ns1lcavgau8k9p6ou7xj3',
       )
     end
   end
 end