tcell_agent 2.1.2 → 2.4.1

data/spec/lib/tcell_agent/instrument_servers_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+def test_rails
+  expect(Rails::Server.instance_methods.include?(:tcell_build_app)).to be_truthy
+end
+
+def test_thin
+  expect(Thin::Server.instance_methods.include?(:original_start)).to be_truthy
+end
+
+def test_unicorn
+  expect(Unicorn::HttpServer::START_CTX[0]).to be_falsy
+  expect(Unicorn::HttpServer.instance_methods.include?(:tcell_init_worker_process)).to be_truthy
+  expect(Unicorn::HttpServer.instance_methods.include?(:tcell_load_config!)).to be_truthy
+end
+
+def test_passenger
+  expect(PhusionPassenger::LoaderSharedHelpers.instance_methods.include?(:tcell_before_handling_requests))
+end
+
+def test_puma
+  expect(Puma.cli_config.options[:preload_app]).to be_falsey
+  expect(Puma::Server.instance_methods.include?(:tcell_original_run)).to be_truthy
+end
+
+def test_server(filenames, funcs)
+  fork do
+    filenames.each do |file|
+      load file
+    end
+
+    load 'tcell_agent/instrument_servers.rb'
+
+    funcs.each do |func|
+      method(func).call
+    end
+  end
+end
+
+describe 'instrument_servers' do
+  context 'with single server dependency' do
+    context 'with webrick server' do
+      it 'should instrument Webrick' do
+        mocks = ['spec/support/server_mocks/rails_mock.rb']
+        tests = [:test_rails]
+        test_server(mocks, tests)
+      end
+    end
+
+    context 'with Thin server' do
+      it 'should instrument Thin' do
+        mocks = ['spec/support/server_mocks/thin_mock.rb']
+        tests = [:test_thin]
+        test_server(mocks, tests)
+      end
+    end
+
+    context 'with Puma server' do
+      it 'should instrument Puma' do
+        mocks = ['spec/support/server_mocks/puma_mock.rb']
+        tests = [:test_puma]
+        test_server(mocks, tests)
+      end
+    end
+
+    context 'with Unicorn server' do
+      it 'should instrument Unicorn' do
+        mocks = ['spec/support/server_mocks/unicorn_mock.rb']
+        tests = [:test_unicorn]
+        test_server(mocks, tests)
+      end
+    end
+
+    context 'with Passenger server' do
+      it 'should instrument Unicorn' do
+        mocks = ['spec/support/server_mocks/passenger_mock.rb']
+        tests = [:test_passenger]
+        test_server(mocks, tests)
+      end
+    end
+  end
+  context 'with multiple server dependencies' do
+    it 'should instrument all servers available' do
+      mocks = ['spec/support/server_mocks/rails_mock.rb',
+               'spec/support/server_mocks/thin_mock.rb',
+               'spec/support/server_mocks/puma_mock.rb',
+               'spec/support/server_mocks/unicorn_mock.rb',
+               'spec/support/server_mocks/passenger_mock.rb']
+
+      tests = %i[test_rails test_thin test_puma test_unicorn test_passenger]
+
+      test_server(mocks, tests)
+    end
+  end
+end

data/spec/lib/tcell_agent/instrumentation/cmdi/io_cmdi_spec.rb

@@ -262,10 +262,10 @@ describe IO do
           IO.popen(@env, %w[echo test], 'w+', :unsetenv_others => true)
 
           expect(TCellAgent::Cmdi).to receive(:block_command?).with('echo test')
-          IO.popen([@env, 'echo', 'test', :unsetenv_others => true], 'w+')
+          IO.popen([@env, 'echo', 'test', { :unsetenv_others => true }], 'w+')
 
           expect(TCellAgent::Cmdi).to receive(:block_command?).with('echo test')
-          IO.popen(@env, [@env, 'echo', 'test', :unsetenv_others => true], 'w+', :err => %i[child out])
+          IO.popen(@env, [@env, 'echo', 'test', { :unsetenv_others => true }], 'w+', :err => %i[child out])
         end
       end
     end

data/spec/lib/tcell_agent/instrumentation/lfi/file_lfi_spec.rb

@@ -1,3 +1,6 @@
+# rubocop:disable Style/HashSyntax
+# rubocop:disable Lint/UselessAssignment
+
 require 'spec_helper'
 require 'securerandom'
 
@@ -12,7 +15,7 @@ describe 'File' do
     )
     @filename = get_test_resource_path('lfi_sample_file.txt')
     @file_contents = "This is line one.\nThis is line two.\n"
-    @new_file_name = '/tmp/' + SecureRandom.uuid
+    @new_file_name = NEW_FILE_NAME
   end
 
   describe '.new' do
@@ -29,298 +32,234 @@ describe 'File' do
         end.to raise_error(Errno::ENOENT)
       end
     end
-    context 'with a non-existent file' do
-      context 'with a directory not blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
-        end
-        context 'with a filename and mode r' do
-          it 'should raise an ERRNO::ENOENT error' do
-            expect do
-              File.new(@new_file_name, 'r')
-            end.to raise_error(Errno::ENOENT)
-          end
-        end
-        context 'with a filename and mode w' do
-          it 'should create the file' do
-            File.new(@new_file_name, 'w')
 
-            expect(File.exist?(@new_file_name)).to be_truthy
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 644' do
-          it 'should create the file with the correct permissions' do
-            File.new(@new_file_name, 'w', 0o644)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('644')
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 755' do
-          it 'should create the file with the correct permissions' do
-            File.new(@new_file_name, 'w', 0o755)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 777' do
-          it 'should create the file with permissions 755' do
-            File.new(@new_file_name, 'w', 0o777)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
-            File.delete(@new_file_name)
-          end
-        end
+    context 'with a file not blocked for read/write' do
+      before(:each) do
+        expect(TCellAgent).to receive(:policy).with(
+          TCellAgent::PolicyTypes::LFI
+        ).and_return(@local_files_policy)
+        expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
       end
-      context 'with a filename blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
-        end
-        context 'with a filename and write mode' do
-          it 'should raise an IOError' do
-            expect do
-              File.new(@new_file_name, 'w')
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and write mode and file permissions 644' do
-          it 'should raise an IOError' do
-            expect do
-              File.new(@new_file_name, 'w', 644)
-            end.to raise_error(IOError)
-          end
+
+      after(:each) do |example|
+      end
+
+      it 'raises an ERRNO::ENOENT error', :file_created => false do
+        expect do
+          File.new(@new_file_name, 'r')
+        end.to raise_error(Errno::ENOENT)
+      end
+
+      it 'creates the file when passed mode w' do
+        File.new(@new_file_name, 'w')
+
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
+      end
+
+      it 'creates the file with the correct permissions' do
+        File.new(@new_file_name, 'w', 0o644)
+
+        expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('644')
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
+      end
+
+      it 'creates the file with the correct permissions' do
+        File.new(@new_file_name, 'w', 0o755)
+
+        expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
+      end
+
+      it 'reads the file' do
+        result = File.new(@filename).read
+        expect(result).to eq @file_contents
+      end
+
+      it 'reads the file when passed a mode' do
+        result = File.new(@filename, 'r').read
+        expect(result).to eq @file_contents
+      end
+
+      it 'writes to the file' do
+        file = File.new('/dev/null', 'w')
+        expect(file.write('dummy message')).to eq 13
+      end
+
+      it 'appends to the file' do
+        file = File.new('/dev/null', 'a')
+        expect(file.write('dummy message')).to eq 13
+      end
+
+      context 'using mode, permission, binmode opt' do
+        after :each do
+          expect(@result.binmode?).to be_truthy
+          expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
+
+          File.delete(@new_file_name) 
         end
+
+        test_ruby2_ruby3_keywords(File,
+                                  'new',
+                                  [NEW_FILE_NAME, 'w', 0o755],
+                                  { binmode: true },
+                                  nil)
       end
     end
-    context 'with an existing file' do
-      context 'with a file not blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
-        end
-        context 'with a filename' do
-          it 'should still be able to read the file' do
-            result = File.new(@filename).read
-            expect(result).to eq @file_contents
-          end
-        end
-        context 'with a filename and mode r' do
-          it 'should still be able to read the file' do
-            result = File.new(@filename, 'r').read
-            expect(result).to eq @file_contents
-          end
-        end
-        context 'with a filenname and mode w' do
-          it 'should still be able to write to a file' do
-            file = File.new('/dev/null', 'w')
-            expect(file.write('dummy message')).to eq 13
-          end
-        end
-        context 'with a filenname and mode a' do
-          it 'should still be able to write to a file' do
-            file = File.new('/dev/null', 'a')
-            expect(file.write('dummy message')).to eq 13
-          end
-        end
+
+    context 'with a file blocked for read/write' do
+      before(:each) do
+        expect(TCellAgent).to receive(:policy).with(
+                                TCellAgent::PolicyTypes::LFI
+                              ).and_return(@local_files_policy)
+        expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
       end
-      context 'with a file blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
-        end
-        context 'with a filename' do
-          it 'should not be able to read the file' do
-            expect do
-              File.new(@filename)
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and mode r' do
-          it 'should not be able to read the file' do
-            expect do
-              File.new(@filename, 'r')
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and mode w' do
-          it 'should not be able to write to the file' do
-            expect do
-              File.new('/dev/null', 'w')
-            end.to raise_error(IOError)
-          end
-        end
+
+      it 'raises an IOError' do
+        expect do
+          File.new(@new_file_name, 'w')
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.new(@new_file_name, 'w', 644)
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.new(@filename)
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.new(@filename, 'r')
+        end.to raise_error(IOError)
+      end
+      it 'raises an IOError' do
+        expect do
+          File.new('/dev/null', 'w')
+        end.to raise_error(IOError)
       end
     end
   end
 
   describe '.open' do
-    context 'empty path' do
-      it 'should raise an error' do
-        expect do
-          File.open
-        end.to raise_error(ArgumentError)
-        expect do
-          File.open(nil)
-        end.to raise_error(TypeError)
+    context 'with a file not blocked for read/write' do
+      before(:each) do
+        expect(TCellAgent).to receive(:policy).with(
+          TCellAgent::PolicyTypes::LFI
+        ).and_return(@local_files_policy)
+        expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
+      end
+
+      it 'raises an ERRNO::ENOENT error', :file_created => false do
         expect do
-          File.open('')
+          File.open(@new_file_name, 'r')
         end.to raise_error(Errno::ENOENT)
       end
-    end
-    context 'with a non-existent file' do
-      before(:all) do
-        @new_file_name = '/tmp/' + SecureRandom.uuid
-      end
-      context 'with a directory not blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
-        end
-        context 'with a filename and mode r' do
-          it 'should raise an ERRNO::ENOENT error' do
-            expect do
-              File.open(@new_file_name, 'r')
-            end.to raise_error(Errno::ENOENT)
-          end
-        end
-        context 'with a filename and mode w' do
-          it 'should create the file' do
-            File.open(@new_file_name, 'w')
 
-            expect(File.exist?(@new_file_name)).to be_truthy
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 644' do
-          it 'should create the file with the correct permissions' do
-            File.open(@new_file_name, 'w', 0o644)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('644')
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 755' do
-          it 'should create the file with the correct permissions' do
-            File.open(@new_file_name, 'w', 0o755)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
-            File.delete(@new_file_name)
-          end
-        end
-        context 'with a filename and write mode and file permissions 777' do
-          it 'should create the file with permissions 755' do
-            File.open(@new_file_name, 'w', 0o777)
-
-            expect(File.exist?(@new_file_name)).to be_truthy
-            expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
-            File.delete(@new_file_name)
-          end
-        end
+      it 'creates the file when passed mode w' do
+        File.open(@new_file_name, 'w')
+
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
       end
-      context 'with a filename blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
-        end
-        context 'with a filename and write mode' do
-          it 'should raise an IOError' do
-            expect do
-              File.open(@new_file_name, 'w')
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and write mode and file permissions 644' do
-          it 'should raise an IOError' do
-            expect do
-              File.open(@new_file_name, 'w', 644)
-            end.to raise_error(IOError)
-          end
+
+      it 'creates the file with the correct permissions' do
+        File.open(@new_file_name, 'w', 0o644)
+
+        expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('644')
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
+      end
+
+      it 'creates the file with the correct permissions' do
+        File.open(@new_file_name, 'w', 0o755)
+
+        expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
+        expect(File.exist?(@new_file_name)).to be_truthy
+        File.delete(@new_file_name) if File.exist?(@new_file_name)
+      end
+
+      it 'reads the file' do
+        result = File.open(@filename).read
+        expect(result).to eq @file_contents
+      end
+
+      it 'reads the file when passed a mode' do
+        result = File.open(@filename, 'r').read
+        expect(result).to eq @file_contents
+      end
+
+      it 'writes to the file' do
+        file = File.open('/dev/null', 'w')
+        expect(file.write('dummy message')).to eq 13
+      end
+
+      it 'appends to the file' do
+        file = File.open('/dev/null', 'a')
+        expect(file.write('dummy message')).to eq 13
+      end
+
+      context 'using mode, permission, binmode opt' do
+        after :each do
+          expect(@result.binmode?).to be_truthy
+          expect(File.stat(@new_file_name).mode.to_s(8)[3..5]).to eq('755')
         end
+
+        test_ruby2_ruby3_keywords(File,
+                                  'open',
+                                  [NEW_FILE_NAME, 'w', 0o755],
+                                  { binmode: true },
+                                  nil)
       end
     end
-    context 'with an existing file' do
-      context 'with a file not blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(false)
-        end
-        context 'with a filename' do
-          it 'should still be able to read the file' do
-            result = File.open(@filename).read
-            expect(result).to eq @file_contents
-          end
-        end
-        context 'with a filename and mode r' do
-          it 'should still be able to read the file' do
-            result = File.open(@filename, 'r').read
-            expect(result).to eq @file_contents
-          end
-        end
-        context 'with a filenname and mode w' do
-          it 'should still be able to write to a file' do
-            file = File.open('/dev/null', 'w')
-            expect(file.write('dummy message')).to eq 13
-          end
-        end
-        context 'with a filenname and mode a' do
-          it 'should still be able to write to a file' do
-            file = File.open('/dev/null', 'a')
-            expect(file.write('dummy message')).to eq 13
-          end
-        end
+
+    context 'with a file blocked for read/write' do
+      before(:each) do
+        expect(TCellAgent).to receive(:policy).with(
+                                TCellAgent::PolicyTypes::LFI
+                              ).and_return(@local_files_policy)
+        expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
       end
-      context 'with a file blocked for read/write' do
-        before(:each) do
-          expect(TCellAgent).to receive(:policy).with(
-            TCellAgent::PolicyTypes::LFI
-          ).and_return(@local_files_policy)
-          expect(@local_files_policy).to receive(:block_file_access?).and_return(true)
-        end
-        context 'with a filename' do
-          it 'should not be able to read the file' do
-            expect do
-              File.open(@filename)
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and mode r' do
-          it 'should not be able to read the file' do
-            expect do
-              File.open(@filename, 'r')
-            end.to raise_error(IOError)
-          end
-        end
-        context 'with a filename and mode w' do
-          it 'should not be able to write to the file' do
-            expect do
-              File.open('/dev/null', 'w')
-            end.to raise_error(IOError)
-          end
-        end
+
+      it 'raises an IOError' do
+        expect do
+          File.open(@new_file_name, 'w')
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.open(@new_file_name, 'w', 644)
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.open(@filename)
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.open(@filename, 'r')
+        end.to raise_error(IOError)
+      end
+
+      it 'raises an IOError' do
+        expect do
+          File.open('/dev/null', 'w')
+        end.to raise_error(IOError)
       end
     end
   end
 end
+
+# # rubocop:enable Style/HashSyntax
+# # rubocop:enable Lint/UselessAssignment