tcell_agent 1.1.12 → 2.2.0

data/spec/lib/tcell_agent/agent/fork_pipe_manager_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-module TCellAgent
-  describe Agent::ForkPipeManager do
-    describe '.send_to_metrics_pipe' do
-      context 'incrementing a route' do
-        it 'should call increment_route on the agent' do
-          expect(TCellAgent).to receive(:increment_route).with('/ma_route', 50)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              '_type' => 'increment_route',
-              'route_id' => '/ma_route',
-              'response_time' => 50
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'discover database fields' do
-        it 'should call discover_database_fields on the agent' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to receive(:discover_database_fields).with(
-            'route_id', 'database', 'schema', 'table', 'fields'
-          )
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              {
-                '_type' => 'discover_database_fields',
-                'route_id' => 'route_id',
-                'database' => 'database',
-                'schema' => 'schema',
-                'table' => 'table',
-                'fields' => 'fields'
-              }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'increment session info' do
-        it 'should call increment_session_info on the agent' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to receive(:increment_session_info).with(
-            'hmac_session_id', 'user_id', 'ip_address', 'user_agent'
-          )
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              {
-                '_type' => 'increment_session_info',
-                'hmac_session_id' => 'hmac_session_id',
-                'user_id' => 'user_id',
-                'ip_address' => 'ip_address',
-                'user_agent' => 'user_agent'
-              }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-
-      context 'unknown metric' do
-        it 'should raise an exception' do
-          expect(TCellAgent).to_not receive(:increment_route)
-          expect(TCellAgent).to_not receive(:discover_database_fields)
-          expect(TCellAgent).to_not receive(:increment_session_info)
-
-          logger = double('logger')
-          expect(TCellAgent).to receive(:logger).and_return(logger)
-          expect(TCellAgent).to receive(:logger).and_return(logger)
-
-          expect(logger).to receive(:debug).with(
-            'Exception in safe_block Handling metrics_pipe_block: StandardError happened, message' \
-            ' is Metrics Pipe Manager received unknown metric: dunno_what_this_is'
-          )
-          expect(logger).to receive(:debug).with(anything)
-
-          child_process = ForkBreak::Process.new do |_breakpoints|
-            TCellAgent::Agent.send_to_metrics_pipe(
-              { '_type' => 'dunno_what_this_is' }
-            )
-          end
-
-          child_process.finish.wait
-        end
-      end
-    end
-  end
-end

data/spec/lib/tcell_agent/agent/policy_manager_spec.rb

@@ -1,535 +0,0 @@
-require 'spec_helper'
-
-module TCellAgent
-  module SensorEvents
-    describe Agent do
-      describe '#start_policy_polling_loop' do
-        context 'should_start_policy_poll disabled' do
-          it 'should not start the policy polling loop' do
-            configuration = double(
-              'configuration',
-              {
-                :should_start_policy_poll? => false,
-                :event_time_limit_seconds => nil,
-                :event_batch_size_limit => nil,
-                :preload_policy_filename => nil,
-                :cache_filename_with_app_id => 'cache-file.app_id'
-              }
-            )
-
-            expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-            agent = TCellAgent::Agent.new
-
-            expect(Thread).to_not receive(:new)
-            agent.start_policy_polling_loop
-          end
-        end
-
-        context 'should_start_policy_poll enabled' do
-          context 'tcell_api_url' do
-            context 'is nil ' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => nil,
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is empty' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => '',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is blank space' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => '    ',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io tcell_api_url is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-          end
-
-          context 'app_id' do
-            context 'is nil ' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => nil,
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is empty' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => '',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-
-            context 'is blank space' do
-              it 'should not start the policy polling loop' do
-                configuration = double(
-                  'configuration',
-                  {
-                    :tcell_api_url => 'present',
-                    :app_id => '    ',
-                    :should_start_policy_poll? => true,
-                    :event_time_limit_seconds => nil,
-                    :event_batch_size_limit => nil,
-                    :preload_policy_filename => nil,
-                    :cache_filename_with_app_id => 'cache-file.app_id'
-                  }
-                )
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                agent = TCellAgent::Agent.new
-
-                logger = double('logger')
-
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:error).with('tCell.io app_id is missing. Disabling policy polling.')
-                expect(Thread).to_not receive(:new)
-                agent.start_policy_polling_loop
-              end
-            end
-          end
-        end
-      end
-
-      describe '#cache' do
-        context 'with an existing cached file' do
-          context 'with two processes' do
-            context 'while one process is writing to the cached file' do
-              before(:each) do
-                configuration = double(
-                  'configuration',
-                  {
-                    'app_id' => 'app_id',
-                    'api_key' => 'api_key',
-                    'allow_payloads' => true,
-                    'js_agent_api_base_url' => 'http://api.tcell.com/',
-                    'js_agent_url' => 'https://jsagent.tcell.io/tcellagent.min.js',
-                    'max_csp_header_bytes' => nil,
-                    'event_time_limit_seconds' => 15,
-                    'event_batch_size_limit' => 50,
-                    'preload_policy_filename' => nil,
-                    'cache_filename_with_app_id' => '/tcellagent_src/tcell/cache/tcell_agent.cache',
-                    'agent_home_owner' => nil
-                  }
-                )
-                expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-                TCellAgent.thread_agent.cache(
-                  'http-redirect',
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                    'data' =>  {
-                      'enabled' => true,
-                      'block' => false,
-                      'whitelist' => []
-                    }
-                  }
-                )
-              end
-
-              it 'should raise a timeout exception when the other process tries to write to it' do
-                file_lock_holder = ForkBreak::Process.new do |breakpoints|
-                  original_dump = JSON.method(:dump)
-                  JSON.stub(:dump) do |*args|
-                    breakpoints << :before_dump
-                    original_dump.call(*args)
-                  end
-
-                  TCellAgent.thread_agent.cache(
-                    'http-redirect',
-                    {
-                      'app_id' => 'raftest-EyJZR',
-                      'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                      'data' =>  {
-                        'enabled' => true,
-                        'block' => false,
-                        'whitelist' => []
-                      }
-                    }
-                  )
-                end
-
-                file_lock_holder.run_until(:before_dump).wait
-
-                logger = double('logger')
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with('execution expired')
-
-                TCellAgent.thread_agent.cache(
-                  'http-redirect',
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => '363b8b60-a9a8-11e5-bb10-a9372a56b8a7',
-                    'data' =>  {
-                      'enabled' => true,
-                      'block' => false,
-                      'whitelist' => []
-                    }
-                  }
-                )
-
-                file_lock_holder.finish.wait
-              end
-
-              after(:each) do
-                File.delete(TCellAgent.configuration.cache_filename_with_app_id)
-              end
-            end
-          end
-        end
-
-        context 'with 10 processes updating the cached file' do
-          xit 'should update the cached file with all updates' do
-            processes = Array.new(5).each do |process_number|
-              ForkBreak::Process.new do |breakpoints|
-                original_dump = JSON.method(:dump)
-                JSON.stub(:dump) do |*args|
-                  breakpoints << :before_dump
-                  original_dump.call(*args)
-                end
-
-                TCellAgent.thread_agent.cache(
-                  "process_#{process_number}",
-                  {
-                    'app_id' => 'raftest-EyJZR',
-                    'policy_id' => 'policy_id',
-                    'data' =>  { 'enabled' => true }
-                  }
-                )
-              end
-            end
-
-            processes.map(&:finish).map(&:wait)
-
-            policies = JSON.parse(File.open(TCellAgent.configuration.cache_filename_with_app_id).read)
-
-            File.delete(TCellAgent.configuration.cache_filename_with_app_id)
-
-            expect(policies).to eq(
-              {
-                'process_0' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_1' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_2' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_3' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } },
-                'process_4' => { 'app_id' => 'raftest-EyJZR', 'policy_id' => 'policy_id', 'data' => { 'enabled' => true } }
-              }
-            )
-          end
-        end
-      end
-
-      describe '#policies_from_cachefile' do
-        context 'with no cache file' do
-          it 'should return nil' do
-            rust_policies = double('rust_policies')
-
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-            expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(false)
-            expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-            agent = TCellAgent::Agent.new(Process.pid)
-
-            expect(agent.policies).to eq({ 'rust' => rust_policies })
-          end
-        end
-
-        context 'with a cache file present' do
-          context 'that is empty' do
-            it 'should raise a json error' do
-              cache_file = double('cache_file')
-              expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-              expect(File).to receive(:open).and_return(cache_file)
-              expect(cache_file).to receive(:flock).and_return(true)
-              expect(cache_file).to receive(:read).and_return('')
-              expect(cache_file).to receive(:close)
-
-              logger = double('logger')
-              expect(TCellAgent).to receive(:logger).and_return(logger)
-              expect(logger).to receive(:warn).with('A JSON text must at least contain two octets!')
-
-              rust_policies = double('rust_policies')
-              expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-
-              expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-
-              agent = TCellAgent::Agent.new(Process.pid)
-
-              expect(agent.policies).to eq({ 'rust' => rust_policies })
-            end
-          end
-
-          context 'that has content' do
-            context 'that is malformed' do
-              it 'should raise a json error' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return('bad_json')
-                expect(cache_file).to receive(:close)
-
-                logger = double('logger')
-                expect(TCellAgent).to receive(:logger).and_return(logger)
-                expect(logger).to receive(:warn).with(/unexpected token at 'bad_json'/)
-                expect_any_instance_of(TCellAgent::Agent).to_not receive(:process_policy_json)
-
-                rust_policies = double('rust_policies')
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(rust_policies)
-
-                agent = TCellAgent::Agent.new(Process.pid)
-
-                expect(agent.policies).to eq({ 'rust' => rust_policies })
-              end
-            end
-
-            context 'that is an empty json object' do
-              it 'should raise a json error' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return('{}')
-                expect(cache_file).to receive(:close)
-
-                expect(TCellAgent).to_not receive(:logger)
-
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with({}, false)
-
-                TCellAgent::Agent.new(Process.pid)
-              end
-            end
-
-            context 'that is a valid policy' do
-              it 'should set the policies' do
-                cache_file = double('cache_file')
-                expect(File).to receive(:exist?).with(%r{tcell/cache/tcell_agent.cache}).and_return(true)
-                expect(File).to receive(:open).and_return(cache_file)
-                expect(cache_file).to receive(:flock).and_return(true)
-                expect(cache_file).to receive(:read).and_return(
-                  {
-                    :process_0 => {
-                      :app_id => 'raftest-EyJZR',
-                      :policy_id => 'policy_id',
-                      :data => { :enabled => true }
-                    }
-                  }.to_json
-                )
-                expect(cache_file).to receive(:close)
-                expect_any_instance_of(TCellAgent::Agent).to receive(:process_policy_json).with(
-                  {
-                    'process_0' => {
-                      'app_id' => 'raftest-EyJZR',
-                      'policy_id' => 'policy_id',
-                      'data' => { 'enabled' => true }
-                    }
-                  },
-                  false
-                )
-                expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-
-                TCellAgent::Agent.new(Process.pid)
-              end
-            end
-          end
-        end
-      end
-
-      describe '#policy_polling_iteration' do
-        context 'with policy polling errors' do
-          it 'should extend failure sleep time after each failure' do
-            configuration = double(
-              'configuration',
-              {
-                :should_start_policy_poll? => false,
-                :event_time_limit_seconds => nil,
-                :event_batch_size_limit => nil,
-                :preload_policy_filename => nil,
-                :cache_filename_with_app_id => 'cache-file.app_id'
-              }
-            )
-
-            api = double('api')
-            logger = double('logger')
-
-            expect(TCellAgent).to receive(:configuration).and_return(configuration).at_least(:once)
-            expect(TCellAgent::TCellApi).to receive(:new).and_return(api)
-            expect(TCellAgent::Policies::RustPolicies).to receive(:new).and_return(nil)
-            agent = TCellAgent::Agent.new
-
-            # failure sleep time should double after each failed attempt to retrieve policies
-            # until it reaches 480 seconds
-            failure_sleep_time = 30
-            last_poll_time = 0
-
-            # 1st attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(60)
-            expect(last_poll_time).to eq(0)
-
-            # 2nd attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(120)
-            expect(last_poll_time).to eq(0)
-
-            # 3rd attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(240)
-            expect(last_poll_time).to eq(0)
-
-            # 4th attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(480)
-            expect(last_poll_time).to eq(0)
-
-            # 5th attempt
-            expect(api).to receive(:poll_api).with(0).and_return(nil)
-            expect(TCellAgent).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:error).with(
-              "Policy was nil. Sleeping for #{failure_sleep_time}"
-            )
-            expect(agent).to receive(:sleep).with(failure_sleep_time)
-            failure_sleep_time, last_poll_time = agent.policy_polling_iteration(failure_sleep_time, last_poll_time)
-
-            expect(failure_sleep_time).to eq(480)
-            expect(last_poll_time).to eq(0)
-          end
-        end
-      end
-    end
-  end
-end