rf_logger 0.0.4 → 0.3.0

data/spec/lib/rf_logger/configuration_spec.rb

@@ -1,4 +1,8 @@
-describe RfLogger::Configuration do
+require "rf_logger/notifications/error_notification"
+require "rf_logger/configuration"
+require "rf_logger/levels"
+
+RSpec.describe RfLogger::Configuration do
   class SomeNotifier; end
   let(:configuration) {described_class.new}
   before :each do
@@ -10,6 +14,7 @@ describe RfLogger::Configuration do
     Object.send(:remove_const, :Rory) if defined?(Rory)
     Object.send(:remove_const, :Padrino) if defined?(Padrino)
     Object.send(:remove_const, :Sinatra) if defined?(Sinatra::Application)
+    configuration.clear!
   end
 
   describe "#environment" do
@@ -19,7 +24,7 @@ describe RfLogger::Configuration do
 
     it 'returns environment set by user' do
       configuration.environment = 'test'
-      configuration.environment.should == 'test'
+      expect(configuration.environment).to eq('test')
     end
 
     it 'uses Rails.env if Rails is defined' do
@@ -29,7 +34,7 @@ describe RfLogger::Configuration do
         end
       end
 
-      configuration.environment.should == 'monkey'
+      expect(configuration.environment).to eq('monkey')
     end
 
     it 'uses Padrino.environment if defined' do
@@ -39,7 +44,7 @@ describe RfLogger::Configuration do
         end
       end
 
-      configuration.environment.should == 'padrino'
+      expect(configuration.environment).to eq('padrino')
     end
 
     it 'uses Sinatra::Application.environment if defined' do
@@ -51,7 +56,7 @@ describe RfLogger::Configuration do
         end
       end
 
-      configuration.environment.should == 'sinatra'
+      expect(configuration.environment).to eq('sinatra')
     end
 
     it 'uses ENV["RORY_STAGE"] if Rory is defined' do
@@ -59,7 +64,7 @@ describe RfLogger::Configuration do
       end
       ENV['RORY_STAGE'] = 'rory'
 
-      configuration.environment.should == 'rory'
+      expect(configuration.environment).to eq('rory')
       ENV['RORY_STAGE'] = nil
     end
 
@@ -84,22 +89,22 @@ describe RfLogger::Configuration do
     it 'resets notification subject' do
       configuration.notification_subject = 'foo'
       configuration.clear!
-      configuration.notification_subject.should be_nil
+      expect(configuration.notification_subject).to be_nil
     end
 
     it 'resets environmental error notifier settings' do
-      RfLogger.configuration.stub(:environment => 'test')
+      allow(RfLogger.configuration).to receive_messages(:environment => 'test')
       configuration.set_notifier_list { |n| n.add_notifier SomeNotifier }
       configuration.clear!
-      configuration.notifiers.keys.should =~ RfLogger::LEVELS
-      configuration.notifiers.values.uniq.should == [[]]
+      expect(configuration.notifiers.keys).to match_array(RfLogger::LEVELS)
+      expect(configuration.notifiers.values.uniq).to eq([[]])
     end
   end
 
   describe 'notification_subject' do
     it 'sets the value' do
       configuration.notification_subject = 'Foo!'
-      configuration.notification_subject.should == 'Foo!'
+      expect(configuration.notification_subject).to eq('Foo!')
     end
   end
 
@@ -107,7 +112,7 @@ describe RfLogger::Configuration do
     class SomeOtherNotifier; end
     class AThirdNotifier; end
     it 'calls add_notifier on ErrorNotification and adds the notifier to config list' do
-      RfLogger.configuration.stub(:environment => 'test')
+      allow(RfLogger.configuration).to receive_messages(:environment => 'test')
 
       configuration.set_notifier_list do |n|
         n.add_notifier SomeNotifier, :only => ['test'], :levels => [:fatal]
@@ -115,9 +120,9 @@ describe RfLogger::Configuration do
         n.add_notifier AThirdNotifier, :levels => [:fatal]
       end
 
-      configuration.notifiers.delete(:fatal).should =~ [SomeNotifier, AThirdNotifier]
+      expect(configuration.notifiers.delete(:fatal)).to match_array([SomeNotifier, AThirdNotifier])
       # all other levels shouldn't have notifiers
-      configuration.notifiers.values.uniq.should == [[]]
+      expect(configuration.notifiers.values.uniq).to eq([[]])
     end
   end
 end

data/spec/lib/rf_logger/log_for_notification_spec.rb

@@ -12,18 +12,18 @@ describe RfLogger::LogForNotification do
 
   describe 'subject' do
     it 'reports log level, actor, and action of the error' do
-      subject.subject.should =~ /ERROR.*fruit_cocktail.*finding_maraschino_cherries/
+      expect(subject.subject).to match(/ERROR.*fruit_cocktail.*finding_maraschino_cherries/)
     end
 
     it 'uses the configured subject, if given' do
       RfLogger.configuration.notification_subject = "Help! {{level}} for {{actor}}/{{action}}"
-      subject.subject.should == "Help! ERROR for fruit_cocktail/finding_maraschino_cherries"
+      expect(subject.subject).to eq("Help! ERROR for fruit_cocktail/finding_maraschino_cherries")
     end
   end
 
   describe 'details' do
     it 'should include metadata' do
-      subject.details.should =~ /something_is_wrong.*with_the_refrigerator/
+      expect(subject.details).to match(/something_is_wrong.*with_the_refrigerator/)
     end
   end
 end

data/spec/lib/rf_logger/notifications/error_notification_environment_constraints_spec.rb

@@ -3,48 +3,62 @@ require 'spec_helper'
 describe RfLogger::ErrorNotification::EnvironmentConstraints do
   describe '#included?' do
     it 'returns true if no constraints for :only are given' do
-      described_class.new('alpha', {}).included?.should be_true
+      expect(described_class.new('alpha', {}).included?).to be(true)
     end
 
     it 'returns true if the environment is included in :only' do
-      described_class.new('alpha', {:only => ['alpha', 'beta']}).included?.should be_true
+      expect(
+        described_class.new('alpha', {:only => ['alpha', 'beta']}).included?
+      ).to be(true)
     end
 
     it 'returns false if the environment is not in :only' do
-      described_class.new('alpha', {:only => ['beta']}).included?.should be_false
+      expect(
+        described_class.new('alpha', {:only => ['beta']}).included?
+      ).to be(false)
     end
   end
 
   describe '#excluded?' do
     it 'returns false if no constraints for :except are given' do
-      described_class.new('alpha', {}).excluded?.should be_false
+      expect(described_class.new('alpha', {}).excluded?).to be(false)
     end
 
     it 'returns true if the environment is included in :except' do
-      described_class.new('alpha', {:except => ['alpha', 'beta']}).excluded?.should be_true
+      expect(
+        described_class.new('alpha', {:except => ['alpha', 'beta']}).excluded?
+      ).to be(true)
     end
 
     it 'returns false if the environment is not in :except' do
-      described_class.new('alpha', {:except => ['beta']}).excluded?.should be_false
+      expect(
+        described_class.new('alpha', {:except => ['beta']}).excluded?
+      ).to be(false)
     end
   end
 
   describe '#valid_notifier?' do
     it 'returns true if there are no constraints' do
-      described_class.new('alpha', nil).valid_notifier?.should be_true
-      described_class.new('alpha', {}).valid_notifier?.should be_true
+      expect(described_class.new('alpha', nil).valid_notifier?).to be(true)
+      expect(described_class.new('alpha', {}).valid_notifier?).to be(true)
     end
 
     it 'returns true if the environment is included in :only and not included in :except' do
-      described_class.new('alpha', {:only => ['alpha'], :except => []}).valid_notifier?.should be_true
+      expect(
+        described_class.new('alpha', {:only => ['alpha'], :except => []}).valid_notifier?
+      ).to be(true)
     end
 
     it 'returns false if the environment is included in :except' do
-      described_class.new('alpha', {:except => ['alpha']}).valid_notifier?.should be_false
+      expect(
+        described_class.new('alpha', {:except => ['alpha']}).valid_notifier?
+      ).to be(false)
     end
 
     it 'returns false if the environment is not in :only' do
-      described_class.new('alpha', {:only => ['beta']}).valid_notifier?.should be_false
+      expect(
+        described_class.new('alpha', {:only => ['beta']}).valid_notifier?
+      ).to be(false)
     end
-  end
+   end
 end

data/spec/lib/rf_logger/notifications/error_notification_spec.rb

@@ -17,9 +17,9 @@ describe RfLogger::ErrorNotification do
         c.add_notifier 'swiftly clean', :levels => [:fatal]
       end
 
-      described_class.notifiers.delete(:error).should =~ ['perfectly refined']
-      described_class.notifiers.delete(:fatal).should =~ ['perfectly refined', 'swiftly clean']
-      described_class.notifiers.values.uniq.should == [[]]
+      expect(described_class.notifiers.delete(:error)).to match_array(['perfectly refined'])
+      expect(described_class.notifiers.delete(:fatal)).to match_array(['perfectly refined', 'swiftly clean'])
+      expect(described_class.notifiers.values.uniq).to eq([[]])
     end
 
     it 'allows multiple types of notification' do
@@ -27,10 +27,10 @@ describe RfLogger::ErrorNotification do
         c.add_notifier 'gravy_pie'
         c.add_notifier 'assiduous_hedgehog'
       end
-      described_class.notifiers.keys.should == RfLogger::LEVELS
+      expect(described_class.notifiers.keys).to eq(RfLogger::LEVELS)
       described_class.notifiers.values.uniq.tap do |unique_notifiers|
-        unique_notifiers.count.should == 1
-        unique_notifiers[0].should =~ ['assiduous_hedgehog', 'gravy_pie']
+        expect(unique_notifiers.count).to eq(1)
+        expect(unique_notifiers[0]).to match_array(['assiduous_hedgehog', 'gravy_pie'])
       end
     end
 
@@ -43,8 +43,8 @@ describe RfLogger::ErrorNotification do
       end
 
       described_class.notifiers.values.uniq.tap do |unique_notifiers|
-        unique_notifiers.count.should == 1
-        unique_notifiers[0].should == ['terribly sweet']
+        expect(unique_notifiers.count).to eq(1)
+        expect(unique_notifiers[0]).to eq(['terribly sweet'])
       end
     end
   end
@@ -60,7 +60,7 @@ describe RfLogger::ErrorNotification do
     it 'calls error_notification on all configured notifiers' do
       log = double(:log, :level => :warn)
       described_class.notifiers[:warn].each do |n|
-        n.should_receive(:send_notification).with(log)
+        expect(n).to receive(:send_notification).with(log)
       end
       described_class.dispatch_error(log)
     end

data/spec/lib/rf_logger/rails/rails_compatibility_spec.rb

@@ -0,0 +1,42 @@
+require "rf_logger/rails/rails_compatibility"
+
+RSpec.describe RfLogger::RailsCompatibility do
+
+  let(:rails_gem_version) { Gem::Version.new(rails_version) }
+  subject { described_class.new(rails_version: rails_gem_version) }
+
+  context "far left" do
+    let(:rails_version) { 2.9 }
+    it { expect { subject.call }.to raise_error(described_class::Incompatible) }
+  end
+
+  context "edge left" do
+    let(:rails_version) { 3.1 }
+    it { expect { subject.call }.to raise_error(described_class::Incompatible) }
+  end
+
+  context "middle edge left" do
+    let(:rails_version) { 3.2 }
+    it { expect { |b| subject.call(&b) }.to yield_control }
+  end
+
+  context "center edge" do
+    let(:rails_version) { 4.0 }
+    it { expect { |b| subject.call(&b) }.to yield_control }
+  end
+
+  context "middle edge right" do
+    let(:rails_version) { "5.0.10" }
+    it { expect { |b| subject.call(&b) }.to yield_control }
+  end
+
+  context "edge right" do
+    let(:rails_version) { 5.1 }
+    it { expect { subject.call }.to raise_error(described_class::Incompatible) }
+  end
+
+  context "far right" do
+    let(:rails_version) {6.0}
+    it { expect { subject.call }.to raise_error(described_class::Incompatible) }
+  end
+end

data/spec/lib/rf_logger/request/request_headers_spec.rb

@@ -0,0 +1,83 @@
+require "rf_logger/request/request_headers"
+require "thread/inheritable_attributes"
+
+RSpec.describe RfLogger::RequestHeaders do
+  before { Thread.current.set_inheritable_attribute(:rf_logger_request_tags, nil) }
+
+  describe "#to_hash" do
+    context "when no type is given" do
+      it "defaults to json" do
+        expect(described_class.new.content_type).to eq "application/json"
+        expect(described_class.new.to_hash).to eq({ "Content-Type" => "application/json" })
+      end
+    end
+
+    context "when providing additional types" do
+      it "returns given type" do
+        expect(described_class.new(type: "application/xml").content_type).to eq "application/xml"
+        expect(described_class.new(type: "application/xml").to_hash).to eq({ "Content-Type" => "application/xml" })
+      end
+    end
+
+    context "when api_token is not given" do
+      it "returns no key or value" do
+        expect(described_class.new.api_token).to eq nil
+        expect(described_class.new.to_hash).to eq({ "Content-Type" => "application/json" })
+      end
+    end
+
+    context "when api_token is given" do
+      it "returns given token" do
+        expect(described_class.new(api_token: "1090").api_token).to eq "1090"
+        expect(described_class.new(api_token: "1090").to_hash).to eq({ "Content-Type" => "application/json", "Api-Token" => "1090" })
+      end
+    end
+
+    context "when request_id is given" do
+      it "returns given request_id" do
+        expect(described_class.new(request_id: "21090").request_id).to eq "21090"
+        expect(described_class.new(request_id: "21090").to_hash).to eq({ "Content-Type" => "application/json", "X-Request-Id" => "21090" })
+      end
+    end
+
+    context "when request_id is not given" do
+      after { Thread.current.set_inheritable_attribute(:rf_logger_request_tags, nil) }
+
+      context "when in the context of a request" do
+        before { Thread.current.set_inheritable_attribute(:rf_logger_request_tags, { request_id: "41087" }) }
+
+        it "returns given request_id" do
+          expect(described_class.new.request_id).to eq "41087"
+          expect(described_class.new.to_hash).to eq({ "Content-Type" => "application/json", "X-Request-Id" => "41087" })
+        end
+      end
+
+      context "when not in the context of a request" do
+        it "returns given request_id" do
+          expect(described_class.new.request_id).to eq nil
+          expect(described_class.new.to_hash).to eq({ "Content-Type" => "application/json" })
+        end
+      end
+    end
+
+    context "given any additional symbol keys" do
+      it "converts them to dashes and uppercases the first letter" do
+        expect(described_class.new(accept:      "application/json",
+                                   api_version: "2.1").to_hash).
+          to eq({ "Content-Type" => "application/json", "Accept" => "application/json", "Api-Version" => "2.1" })
+      end
+    end
+
+    context "given the key of other" do
+      it "leaves the key name as is" do
+        expect(described_class.new(other: { "API_Version" => "10" }).to_hash).
+          to eq({ "Content-Type" => "application/json", "API_Version" => "10" })
+      end
+
+      it "excludes any key values where the values is nil" do
+        expect(described_class.new(other: { "API_Version" => nil }).to_hash).
+          to eq({ "Content-Type" => "application/json" })
+      end
+    end
+  end
+end

data/spec/lib/rf_logger/request/request_middleware_spec.rb

@@ -0,0 +1,35 @@
+require "rf_logger/request/request_middleware"
+
+RSpec.describe RfLogger::RequestMiddleware do
+  subject { RfLogger::RequestMiddleware.new(*init_arguments).call(env) }
+  let(:env) { {} }
+  let(:init_arguments) { [->(_) {}] }
+  after { Thread.current[:rf_logger_request_id] = nil }
+
+  context "when tagged is missing" do
+    let(:env) { { "X-Request-Id" => "uuid-from_env" } }
+    it "defaults to getting the request_id" do
+      subject
+      expect(Thread.current[:inheritable_attributes][:rf_logger_request_tags]).to eq({ :request_id => "uuid-from_env" })
+    end
+  end
+
+  context "when tagged option is given that exists" do
+    let(:env) { { "X-OtherHeader" => "other_request_id" } }
+    let(:init_arguments) { [->(_) {}, tagged: { custom_env_key: "X-OtherHeader" }] }
+
+    it "sets current Thread variable" do
+      subject
+      expect(Thread.current[:inheritable_attributes][:rf_logger_request_tags]).to eq({ :custom_env_key => "other_request_id" })
+    end
+  end
+
+  context "when tagged option is given that does not exists" do
+    let(:init_arguments) { [->(_) {}, tagged: { custom_env_key: "X-WontFindMe" }] }
+
+    it "sets current Thread variable" do
+      subject
+      expect(Thread.current[:inheritable_attributes][:rf_logger_request_tags]).to eq({:custom_env_key=>nil})
+    end
+  end
+end

data/spec/lib/rf_logger/{sequel_logger_spec.rb → sequel/logger_spec.rb}

@@ -1,26 +1,33 @@
 require 'sequel'
-DB = Sequel.mock
-require File.expand_path( File.dirname( __FILE__ ) + '/../../../lib/rf_logger/sequel_logger' )
+Sequel::Model.db = Sequel.mock
+require "rf_logger/sequel/logger"
+
+describe RfLogger::Sequel::Logger do
+  include_examples "RfLogger::RequestId", subject: described_class
+
+  it "keeps backwards compatibility" do
+    expect(described_class).to eq RfLogger::SequelLogger
+  end
 
-describe RfLogger::SequelLogger do
   before :each do
-    Time.stub(:now => 'NOW')
-    described_class.dataset = 
-      DB[:logs].columns(:actor, :action, :target_type, :target_id,
+    allow(Time).to receive_messages(:now => 'NOW')
+    described_class.dataset =
+      Sequel::Model.db[:logs].columns(:actor, :action, :target_type, :target_id,
                :metadata, :created_at, :updated_at, :level)
+    allow(described_class).to receive(:rf_logger_request_tags){{request_id: "909090"}}
   end
 
   RfLogger::LEVELS.each do |level|
     describe ".#{level}" do
       it "logs information in the database with #{level.upcase} level" do
-        described_class.should_receive(:add).
+        expect(described_class).to receive(:add).
           with(level, :something => :happened)
         described_class.send(level.to_sym, :something => :happened)
       end
 
       it 'dispatches error notifications' do
-        described_class.stub(:add)
-        RfLogger::ErrorNotification.should_receive(:dispatch_error)
+        allow(described_class).to receive(:add)
+        expect(RfLogger::ErrorNotification).to receive(:dispatch_error)
         described_class.send(level.to_sym, :something => :happened)
       end
     end
@@ -28,7 +35,7 @@ describe RfLogger::SequelLogger do
 
   describe '.add' do
     it 'adds given object to the log at given level' do
-      RfLogger::SequelLogger.should_receive(:create).with(
+      expect(described_class).to receive(:create).with(
         :actor => 'cat herder',
         :action => 'herd some cats',
         :target_type => 'Cat',
@@ -38,7 +45,8 @@ describe RfLogger::SequelLogger do
           :danger => {
             :level => 'really_high',
             :rodent => 'mouse',
-          }
+          },
+          :request_tags => { :request_id => "909090" }
         },
         :level => RfLogger::LEVELS.index(:info),
         :created_at => 'NOW',
@@ -54,16 +62,31 @@ describe RfLogger::SequelLogger do
           :danger => {
             :level => 'really_high',
             :rodent => 'mouse',
-          }
+          },
+          :request_tags => { :request_id => "909090" }
         }
       })
     end
 
+    context "when rf_logger_request_tags is empty" do
+      it "return a metadata with no request_tags key" do
+        allow(described_class).to receive(:rf_logger_request_tags){nil}
+
+        expect(described_class).to receive(:create).with(
+          ({ :level      => 1,
+             :actor      => "",
+             :metadata   => { },
+             :created_at => "NOW" })
+        )
+        described_class.add(:info, {})
+      end
+    end
+
     it 'sets actor to blank string if not provided' do
-      described_class.should_receive(:create).with(
+      expect(described_class).to receive(:create).with(
         :actor => '',
         :action => 'palpitate',
-        :metadata => {},
+        :metadata => {:request_tags=>{:request_id=>"909090"}},
         :created_at => 'NOW',
         :level => RfLogger::LEVELS.index(:info))
 
@@ -71,21 +94,28 @@ describe RfLogger::SequelLogger do
     end
 
     it 'sets metadata to empty hash if not provided' do
-      described_class.should_receive(:create).with(
+      expect(described_class).to receive(:create).with(
         :actor => '',
         :action => 'palpitate',
-        :metadata => {},
+        :metadata => {:request_tags=>{:request_id=>"909090"}},
         :created_at => 'NOW',
         :level => RfLogger::LEVELS.index(:info)
       )
 
       described_class.add(:info, { :action => 'palpitate' })
     end
+  end
 
+  describe "#metadata" do
     it 'returns a hash for metadata even though it is stored as JSON' do
       subject.metadata = {'foo' => 'bar'}
       expect(subject.metadata).to eq({'foo' => 'bar'})
     end
+
+    it 'returns nil if column is null' do
+      subject.metadata = nil
+      expect(subject.metadata).to be_nil
+    end
   end
 
   describe 'display_level' do

data/spec/lib/rf_logger/simple_logger_spec.rb

@@ -6,7 +6,7 @@ describe RfLogger::SimpleLogger do
   RfLogger::LEVELS.each do |level|
     describe ".#{level}" do
       it "adds given object to the log with '#{level}' level" do
-        described_class.should_receive(:add).
+        expect(described_class).to receive(:add).
           with(level, :something => :happened)
         described_class.send(level.to_sym, :something => :happened)
       end
@@ -17,10 +17,10 @@ describe RfLogger::SimpleLogger do
     it 'adds given object to the log at given level' do
       described_class.add(:info, :super_serious_occurrence)
       described_class.add(:debug, :weird_thing)
-      described_class.entries.should == [
+      expect(described_class.entries).to eq([
         { :level => 1, :level_name => :info, :entry => :super_serious_occurrence },
         { :level => 0, :level_name => :debug, :entry => :weird_thing }
-      ]
+      ])
     end
   end
 
@@ -30,22 +30,22 @@ describe RfLogger::SimpleLogger do
       described_class.debug 'other thing'
       described_class.info 'third thing'
       described_class.fatal 'final thing'
-      described_class.entries.should == [
+      expect(described_class.entries).to eq([
         { :level => 1, :level_name => :info, :entry => 'thing' },
         { :level => 0, :level_name => :debug, :entry => 'other thing' },
         { :level => 1, :level_name => :info, :entry => 'third thing' },
         { :level => 4, :level_name => :fatal, :entry => 'final thing' }
-      ]
+      ])
     end
   end
 
   describe '.clear!' do
     it 'deletes all entries' do
-      described_class.entries.should be_empty
+      expect(described_class.entries).to be_empty
       described_class.info 'thing'
-      described_class.entries.should_not be_empty
+      expect(described_class.entries).not_to be_empty
       described_class.clear!
-      described_class.entries.should be_empty
+      expect(described_class.entries).to be_empty
     end
   end
 end

data/spec/lib/rf_logger_spec.rb

@@ -1,3 +1,5 @@
+require "rf_logger/sequel/base"
+
 describe RfLogger do
   describe ".configure" do
     it 'yields the current configuration' do
@@ -16,8 +18,8 @@ describe RfLogger do
         c.environment = 'production'
       end
 
-      described_class.configuration.notification_subject.should == 'Foo'
-      described_class.configuration.environment.should == 'production'
+      expect(described_class.configuration.notification_subject).to eq('Foo')
+      expect(described_class.configuration.environment).to eq('production')
     end
 
     it 'requires a block' do
@@ -45,25 +47,25 @@ describe RfLogger do
     it 'resets configuration' do
       old_config = described_class.configuration
       described_class.clear_configuration!
-      described_class.configuration.should_not == old_config
+      expect(described_class.configuration).not_to eq(old_config)
     end
   end
 
   describe '.environment' do
     it 'can set directly' do
       described_class.environment = 'foo'
-      described_class.configuration.environment.should == 'foo'
+      expect(described_class.configuration.environment).to eq('foo')
     end
   end
 
   describe '.configuration' do
     it 'creates an instance of RfLogger::Configuration' do
-      described_class.configuration.should be_an_instance_of(RfLogger::Configuration)
+      expect(described_class.configuration).to be_an_instance_of(RfLogger::Configuration)
     end
 
     it 'returns the same instance when called multiple times' do
       configuration = described_class.configuration
-      described_class.configuration.should == configuration
+      expect(described_class.configuration).to eq(configuration)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require 'simplecov'
 SimpleCov.start
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
@@ -8,7 +10,6 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 require './lib/rf_logger'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.order = 'random'
 end