From 847b9b35083f6b6ccc95d87aa784c64440e8382d Mon Sep 17 00:00:00 2001 From: Mike Baamonde Date: Tue, 8 Nov 2022 09:47:35 -0500 Subject: [PATCH] Cut down on the amount of INFO-level logging (#1607) --- esrally/actor.py | 10 +++--- esrally/client/factory.py | 27 +++++++------- esrally/driver/driver.py | 64 +++++++++++++++++++++------------- esrally/mechanic/mechanic.py | 2 +- esrally/racecontrol.py | 5 ++- esrally/rally.py | 2 +- esrally/track/params.py | 4 +-- tests/client/factory_test.py | 20 +++++------ tests/driver/scheduler_test.py | 3 -- 9 files changed, 73 insertions(+), 64 deletions(-) diff --git a/esrally/actor.py b/esrally/actor.py index e32f0bc27..a81013c5c 100644 --- a/esrally/actor.py +++ b/esrally/actor.py @@ -119,9 +119,9 @@ def actorSystemCapabilityCheck(capabilities, requirements): current = capabilities.get(name, None) if current != value: # A mismatch by is not a problem by itself as long as at least one actor system instance matches the requirements. - logger.info("Checking capabilities [%s] against requirements [%s] failed.", capabilities, requirements) + logger.debug("Checking capabilities [%s] against requirements [%s] failed.", capabilities, requirements) return False - logger.info("Capabilities [%s] match requirements [%s].", capabilities, requirements) + logger.debug("Capabilities [%s] match requirements [%s].", capabilities, requirements) return True def transition_when_all_children_responded(self, sender, msg, expected_status, new_status, transition): @@ -176,7 +176,7 @@ def send_to_children_and_transition(self, sender, msg, expected_status, new_stat :param new_status: The new status. """ if self.is_current_status_expected(expected_status): - self.logger.info("Transitioning from [%s] to [%s].", self.status, new_status) + self.logger.debug("Transitioning from [%s] to [%s].", self.status, new_status) self.status = new_status for m in filter(None, self.children): self.send(m, msg) @@ -225,10 +225,10 @@ def bootstrap_actor_system(try_join=False, prefer_local_only=False, local_ip=Non try: if try_join: if actor_system_already_running(): - logger.info("Joining already running actor system with system base [%s].", system_base) + logger.debug("Joining already running actor system with system base [%s].", system_base) return thespian.actors.ActorSystem(system_base) else: - logger.info("Creating new actor system with system base [%s] on coordinator node.", system_base) + logger.debug("Creating new actor system with system base [%s] on coordinator node.", system_base) # if we try to join we can only run on the coordinator... return thespian.actors.ActorSystem(system_base, logDefs=log.load_configuration(), capabilities={"coordinator": True}) elif prefer_local_only: diff --git a/esrally/client/factory.py b/esrally/client/factory.py index e240b8c0e..baf26a7ec 100644 --- a/esrally/client/factory.py +++ b/esrally/client/factory.py @@ -49,7 +49,7 @@ def __init__(self, hosts, client_options): # pylint: disable=import-outside-toplevel import ssl - self.logger.info("SSL support: on") + self.logger.debug("SSL support: on") self.client_options["scheme"] = "https" self.ssl_context = ssl.create_default_context( @@ -57,7 +57,7 @@ def __init__(self, hosts, client_options): ) if not self.client_options.pop("verify_certs", True): - self.logger.info("SSL certificate verification: off") + self.logger.debug("SSL certificate verification: off") # order matters to avoid ValueError: check_hostname needs a SSL context with either CERT_OPTIONAL or CERT_REQUIRED self.ssl_context.check_hostname = False self.ssl_context.verify_mode = ssl.CERT_NONE @@ -74,14 +74,14 @@ def __init__(self, hosts, client_options): # check_hostname should not be set when host is an IP address self.ssl_context.check_hostname = self._only_hostnames(hosts) self.ssl_context.verify_mode = ssl.CERT_REQUIRED - self.logger.info("SSL certificate verification: on") + self.logger.debug("SSL certificate verification: on") # When using SSL_context, all SSL related kwargs in client options get ignored client_cert = self.client_options.pop("client_cert", False) client_key = self.client_options.pop("client_key", False) if not client_cert and not client_key: - self.logger.info("SSL client authentication: off") + self.logger.debug("SSL client authentication: off") elif bool(client_cert) != bool(client_key): self.logger.error("Supplied client-options contain only one of client_cert/client_key. ") defined_client_ssl_option = "client_key" if client_key else "client_cert" @@ -101,10 +101,10 @@ def __init__(self, hosts, client_options): ) ) elif client_cert and client_key: - self.logger.info("SSL client authentication: on") + self.logger.debug("SSL client authentication: on") self.ssl_context.load_cert_chain(certfile=client_cert, keyfile=client_key) else: - self.logger.info("SSL support: off") + self.logger.debug("SSL support: off") self.client_options["scheme"] = "http" if self._is_set(self.client_options, "create_api_key_per_client"): @@ -126,24 +126,24 @@ def __init__(self, hosts, client_options): "to 'create_api_key_per_client' in order to create client API keys." ) ) - self.logger.info("Automatic creation of client API keys: on") + self.logger.debug("Automatic creation of client API keys: on") else: - self.logger.info("Automatic creation of client API keys: off") + self.logger.debug("Automatic creation of client API keys: off") if self._is_set(self.client_options, "basic_auth_user") and self._is_set(self.client_options, "basic_auth_password"): - self.logger.info("HTTP basic authentication: on") + self.logger.debug("HTTP basic authentication: on") self.client_options["http_auth"] = (self.client_options.pop("basic_auth_user"), self.client_options.pop("basic_auth_password")) else: - self.logger.info("HTTP basic authentication: off") + self.logger.debug("HTTP basic authentication: off") if self._is_set(self.client_options, "compressed"): console.warn("You set the deprecated client option 'compressed‘. Please use 'http_compress' instead.", logger=self.logger) self.client_options["http_compress"] = self.client_options.pop("compressed") if self._is_set(self.client_options, "http_compress"): - self.logger.info("HTTP compression: on") + self.logger.debug("HTTP compression: on") else: - self.logger.info("HTTP compression: off") + self.logger.debug("HTTP compression: off") if self._is_set(self.client_options, "enable_cleanup_closed"): self.client_options["enable_cleanup_closed"] = convert.to_bool(self.client_options.pop("enable_cleanup_closed")) @@ -240,7 +240,6 @@ def wait_for_rest_layer(es, max_attempts=40): expected_node_count = len(es.transport.hosts) logger = logging.getLogger(__name__) for attempt in range(max_attempts): - logger.debug("REST API is available after %s attempts", attempt) # pylint: disable=import-outside-toplevel import elasticsearch @@ -248,7 +247,7 @@ def wait_for_rest_layer(es, max_attempts=40): # see also WaitForHttpResource in Elasticsearch tests. Contrary to the ES tests we consider the API also # available when the cluster status is RED (as long as all required nodes are present) es.cluster.health(wait_for_nodes=">={}".format(expected_node_count)) - logger.info("REST API is available for >= [%s] nodes after [%s] attempts.", expected_node_count, attempt) + logger.debug("REST API is available for >= [%s] nodes after [%s] attempts.", expected_node_count, attempt) return True except elasticsearch.ConnectionError as e: if "SSL: UNKNOWN_PROTOCOL" in str(e): diff --git a/esrally/driver/driver.py b/esrally/driver/driver.py index 52df4de0f..d3b225177 100644 --- a/esrally/driver/driver.py +++ b/esrally/driver/driver.py @@ -255,15 +255,15 @@ def receiveMsg_ChildActorExited(self, msg, sender): if msg.childAddress in self.coordinator.workers: worker_index = self.coordinator.workers.index(msg.childAddress) if self.status == "exiting": - self.logger.info("Worker [%d] has exited.", worker_index) + self.logger.debug("Worker [%d] has exited.", worker_index) else: self.logger.error("Worker [%d] has exited prematurely. Aborting benchmark.", worker_index) self.send(self.start_sender, actor.BenchmarkFailure("Worker [{}] has exited prematurely.".format(worker_index))) else: - self.logger.info("A track preparator has exited.") + self.logger.debug("A track preparator has exited.") def receiveUnrecognizedMessage(self, msg, sender): - self.logger.info("Main driver received unknown message [%s] (ignoring).", str(msg)) + self.logger.debug("Main driver received unknown message [%s] (ignoring).", str(msg)) @actor.no_retry("driver") # pylint: disable=no-value-for-parameter def receiveMsg_PrepareBenchmark(self, msg, sender): @@ -479,7 +479,7 @@ def receiveMsg_Bootstrap(self, msg, sender): @actor.no_retry("track preparator") # pylint: disable=no-value-for-parameter def receiveMsg_ActorExitRequest(self, msg, sender): - self.logger.info("ActorExitRequest received. Forwarding to children") + self.logger.debug("ActorExitRequest received. Forwarding to children") for child in self.children: self.send(child, msg) @@ -727,7 +727,7 @@ def start_benchmark(self): self.logger.info("Benchmark consists of [%d] steps executed by [%d] clients.", self.number_of_steps, len(self.allocations)) # avoid flooding the log if there are too many clients if allocator.clients < 128: - self.logger.info("Allocation matrix:\n%s", "\n".join([str(a) for a in self.allocations])) + self.logger.debug("Allocation matrix:\n%s", "\n".join([str(a) for a in self.allocations])) create_api_keys = self.config.opts("client", "options").all_client_options["default"].get("create_api_key_per_client", None) worker_assignments = calculate_worker_assignments(self.load_driver_hosts, allocator.clients) @@ -737,7 +737,7 @@ def start_benchmark(self): for clients in assignment["workers"]: # don't assign workers without any clients if len(clients) > 0: - self.logger.info("Allocating worker [%d] on [%s] with [%d] clients.", worker_id, host, len(clients)) + self.logger.debug("Allocating worker [%d] on [%s] with [%d] clients.", worker_id, host, len(clients)) worker = self.target.create_client(host, self.config) client_allocations = ClientAllocations() @@ -764,7 +764,7 @@ def start_benchmark(self): def joinpoint_reached(self, worker_id, worker_local_timestamp, task_allocations): self.currently_completed += 1 self.workers_completed_current_step[worker_id] = (worker_local_timestamp, time.perf_counter()) - self.logger.info( + self.logger.debug( "[%d/%d] workers reached join point [%d/%d].", self.currently_completed, len(self.workers), @@ -834,7 +834,7 @@ def move_to_next_task(self, workers_curr_step): for worker_id, worker in enumerate(self.workers): worker_ended_task_at, master_received_msg_at = workers_curr_step[worker_id] worker_start_timestamp = worker_ended_task_at + (start_next_task - master_received_msg_at) - self.logger.info( + self.logger.debug( "Scheduling next task for worker id [%d] at their timestamp [%f] (master timestamp [%f])", worker_id, worker_start_timestamp, @@ -1212,7 +1212,7 @@ def receiveMsg_StartWorker(self, msg, sender): @actor.no_retry("worker") # pylint: disable=no-value-for-parameter def receiveMsg_Drive(self, msg, sender): sleep_time = datetime.timedelta(seconds=msg.client_start_timestamp - time.perf_counter()) - self.logger.info( + self.logger.debug( "Worker[%d] is continuing its work at task index [%d] on [%f], that is in [%s].", self.worker_id, self.current_task_index, @@ -1259,7 +1259,7 @@ def receiveMsg_WakeupMessage(self, msg, sender): # deserialized on the receiver so we convert it here to a plain string. self.send(self.master, actor.BenchmarkFailure("Error in load generator [{}]".format(self.worker_id), str(e))) else: - self.logger.info("Worker[%s] is ready for the next task.", str(self.worker_id)) + self.logger.debug("Worker[%s] is ready for the next task.", str(self.worker_id)) self.executor_future = None self.drive() else: @@ -1282,18 +1282,18 @@ def receiveMsg_WakeupMessage(self, msg, sender): self.wakeupAfter(datetime.timedelta(seconds=self.wakeup_interval)) def receiveMsg_ActorExitRequest(self, msg, sender): - self.logger.info("Worker[%s] has received ActorExitRequest.", str(self.worker_id)) + self.logger.debug("Worker[%s] has received ActorExitRequest.", str(self.worker_id)) if self.executor_future is not None and self.executor_future.running(): self.cancel.set() self.pool.shutdown() - self.logger.info("Worker[%s] is exiting due to ActorExitRequest.", str(self.worker_id)) + self.logger.debug("Worker[%s] is exiting due to ActorExitRequest.", str(self.worker_id)) def receiveMsg_BenchmarkFailure(self, msg, sender): # sent by our no_retry infrastructure; forward to master self.send(self.master, msg) def receiveUnrecognizedMessage(self, msg, sender): - self.logger.info("Worker[%d] received unknown message [%s] (ignoring).", self.worker_id, str(msg)) + self.logger.debug("Worker[%d] received unknown message [%s] (ignoring).", self.worker_id, str(msg)) def drive(self): task_allocations = self.current_tasks_and_advance() @@ -1302,7 +1302,7 @@ def drive(self): task_allocations = self.current_tasks_and_advance() if self.at_joinpoint(): - self.logger.info("Worker[%d] reached join point at index [%d].", self.worker_id, self.current_task_index) + self.logger.debug("Worker[%d] reached join point at index [%d].", self.worker_id, self.current_task_index) # clients that don't execute tasks don't need to care about waiting if self.executor_future is not None: self.executor_future.result() @@ -1322,10 +1322,18 @@ def drive(self): self.current_task_index, ) else: - self.logger.info("Worker[%d] is executing tasks at index [%d].", self.worker_id, self.current_task_index) + self.logger.debug("Worker[%d] is executing tasks at index [%d].", self.worker_id, self.current_task_index) self.sampler = Sampler(start_timestamp=time.perf_counter(), buffer_size=self.sample_queue_size) executor = AsyncIoAdapter( - self.config, self.track, task_allocations, self.sampler, self.cancel, self.complete, self.on_error, self.client_contexts + self.config, + self.track, + task_allocations, + self.sampler, + self.cancel, + self.complete, + self.on_error, + self.client_contexts, + self.worker_id, ) self.executor_future = self.pool.submit(executor) @@ -1678,7 +1686,7 @@ def map_task_throughput(self, current_samples): class AsyncIoAdapter: - def __init__(self, cfg, track, task_allocations, sampler, cancel, complete, abort_on_error, client_contexts): + def __init__(self, cfg, track, task_allocations, sampler, cancel, complete, abort_on_error, client_contexts, worker_id): self.cfg = cfg self.track = track self.task_allocations = task_allocations @@ -1687,6 +1695,7 @@ def __init__(self, cfg, track, task_allocations, sampler, cancel, complete, abor self.complete = complete self.abort_on_error = abort_on_error self.client_contexts = client_contexts + self.parent_worker_id = worker_id self.profiling_enabled = self.cfg.opts("driver", "profiling") self.assertions_enabled = self.cfg.opts("driver", "assertions") self.debug_event_loop = self.cfg.opts("system", "async.debug", mandatory=False, default_value=False) @@ -1720,7 +1729,8 @@ def es_clients(client_id, all_hosts, all_client_options): es[cluster_name] = client.EsClientFactory(cluster_hosts, all_client_options[cluster_name]).create_async(api_key=api_key) return es - self.logger.info("Task assertions enabled: %s", str(self.assertions_enabled)) + if self.assertions_enabled: + self.logger.info("Task assertions enabled") runner.enable_assertions(self.assertions_enabled) clients = [] @@ -1740,20 +1750,24 @@ def es_clients(client_id, all_hosts, all_client_options): ) final_executor = AsyncProfiler(async_executor) if self.profiling_enabled else async_executor aws.append(final_executor()) + task_names = [t.task.task.name for t in self.task_allocations] + self.logger.info("Worker[%s] executing tasks: %s", self.parent_worker_id, task_names) run_start = time.perf_counter() try: _ = await asyncio.gather(*aws) finally: run_end = time.perf_counter() - self.logger.info("Total run duration: %f seconds.", (run_end - run_start)) + self.logger.info( + "Worker[%s] finished executing tasks %s in %f seconds", self.parent_worker_id, task_names, (run_end - run_start) + ) await asyncio.get_event_loop().shutdown_asyncgens() shutdown_asyncgens_end = time.perf_counter() - self.logger.info("Total time to shutdown asyncgens: %f seconds.", (shutdown_asyncgens_end - run_end)) + self.logger.debug("Total time to shutdown asyncgens: %f seconds.", (shutdown_asyncgens_end - run_end)) for c in clients: for es in c.values(): await es.close() transport_close_end = time.perf_counter() - self.logger.info("Total time to close transports: %f seconds.", (transport_close_end - shutdown_asyncgens_end)) + self.logger.debug("Total time to close transports: %f seconds.", (transport_close_end - shutdown_asyncgens_end)) class AsyncProfiler: @@ -2203,7 +2217,7 @@ def schedule_for(task_allocation, parameter_source): # guard all logging statements with the client index and only emit them for the first client. This information is # repetitive and may cause issues in thespian with many clients (an excessive number of actor messages is sent). if client_index == 0: - logger.info("Choosing [%s] for [%s].", sched, task) + logger.debug("Choosing [%s] for [%s].", sched, task) runner_for_op = runner.runner_for(op.type) params_for_op = parameter_source.partition(client_index, task.clients) if hasattr(sched, "parameter_source"): @@ -2233,7 +2247,7 @@ def schedule_for(task_allocation, parameter_source): else: iterations = None if client_index == 0: - logger.info( + logger.debug( "Creating iteration-count based schedule with [%s] distribution for [%s] with [%s] warmup " "iterations and [%s] iterations.", task.schedule, @@ -2245,9 +2259,9 @@ def schedule_for(task_allocation, parameter_source): if client_index == 0: if loop_control.infinite: - logger.info("Parameter source will determine when the schedule for [%s] terminates.", task.name) + logger.debug("Parameter source will determine when the schedule for [%s] terminates.", task.name) else: - logger.info("%s schedule will determine when the schedule for [%s] terminates.", str(loop_control), task.name) + logger.debug("%s schedule will determine when the schedule for [%s] terminates.", str(loop_control), task.name) return ScheduleHandle(task_allocation, sched, loop_control, runner_for_op, params_for_op) diff --git a/esrally/mechanic/mechanic.py b/esrally/mechanic/mechanic.py index 93fb4617e..e64382fa2 100644 --- a/esrally/mechanic/mechanic.py +++ b/esrally/mechanic/mechanic.py @@ -348,7 +348,7 @@ def __init__(self): self.externally_provisioned = False def receiveUnrecognizedMessage(self, msg, sender): - self.logger.info("MechanicActor#receiveMessage unrecognized(msg = [%s] sender = [%s])", str(type(msg)), str(sender)) + self.logger.debug("MechanicActor#receiveMessage unrecognized(msg = [%s] sender = [%s])", str(type(msg)), str(sender)) def receiveMsg_ChildActorExited(self, msg, sender): if self.is_current_status_expected(["cluster_stopping", "cluster_stopped"]): diff --git a/esrally/racecontrol.py b/esrally/racecontrol.py index bf3f1d32b..4d6f63a0c 100644 --- a/esrally/racecontrol.py +++ b/esrally/racecontrol.py @@ -94,13 +94,13 @@ def __init__(self): self.coordinator = None def receiveMsg_PoisonMessage(self, msg, sender): - self.logger.info("BenchmarkActor got notified of poison message [%s] (forwarding).", (str(msg))) + self.logger.debug("BenchmarkActor got notified of poison message [%s] (forwarding).", (str(msg))) if self.coordinator: self.coordinator.error = True self.send(self.start_sender, msg) def receiveUnrecognizedMessage(self, msg, sender): - self.logger.info("BenchmarkActor received unknown message [%s] (ignoring).", (str(msg))) + self.logger.debug("BenchmarkActor received unknown message [%s] (ignoring).", (str(msg))) @actor.no_retry("race control") # pylint: disable=no-value-for-parameter def receiveMsg_Setup(self, msg, sender): @@ -230,7 +230,6 @@ def on_preparation_complete(self, distribution_flavor, distribution_version, rev ) def on_task_finished(self, new_metrics): - self.logger.info("Task has finished.") self.logger.info("Bulk adding request metrics to metrics store.") self.metrics_store.bulk_add(new_metrics) diff --git a/esrally/rally.py b/esrally/rally.py index 56c1106c0..a01c413d0 100644 --- a/esrally/rally.py +++ b/esrally/rally.py @@ -1191,7 +1191,7 @@ def _trap(function, path, exc_info): raise exceptions.SystemSetupError(f"Unable to clean [{paths.libs()}]. See Rally log for more information.") # fully destructive is fine, we only allow one Rally to run at a time and we will rely on the pip cache for download caching - logging.info("Cleaning track dependency directory [%s]...", paths.libs()) + logger.info("Cleaning track dependency directory [%s]...", paths.libs()) shutil.rmtree(paths.libs(), onerror=_trap) result = dispatch_sub_command(arg_parser, args, cfg) diff --git a/esrally/track/params.py b/esrally/track/params.py index ea32b6675..a5a15ee99 100644 --- a/esrally/track/params.py +++ b/esrally/track/params.py @@ -965,7 +965,7 @@ def create_readers( target = f"{docs.target_index}/{docs.target_type}" if docs.target_index else "/" if docs.target_data_stream: target = docs.target_data_stream - logger.info( + logger.debug( "Task-relative clients at index [%d-%d] will bulk index [%d] docs starting from line offset [%d] for [%s] " "from corpus [%s].", start_client_index, @@ -979,7 +979,7 @@ def create_readers( docs, offset, num_lines, num_docs, batch_size, bulk_size, id_conflicts, conflict_probability, on_conflict, recency ) else: - logger.info( + logger.debug( "Task-relative clients at index [%d-%d] skip [%s] (no documents to read).", start_client_index, end_client_index, diff --git a/tests/client/factory_test.py b/tests/client/factory_test.py index 966789da0..fb4565551 100644 --- a/tests/client/factory_test.py +++ b/tests/client/factory_test.py @@ -66,9 +66,9 @@ def test_create_https_connection_verify_server(self, mocked_load_cert_chain): original_client_options = deepcopy(client_options) logger = logging.getLogger("esrally.client.factory") - with mock.patch.object(logger, "info") as mocked_info_logger: + with mock.patch.object(logger, "debug") as mocked_debug_logger: f = client.EsClientFactory(hosts, client_options) - mocked_info_logger.assert_has_calls( + mocked_debug_logger.assert_has_calls( [ mock.call("SSL support: on"), mock.call("SSL certificate verification: on"), @@ -107,9 +107,9 @@ def test_create_https_connection_verify_self_signed_server_and_client_certificat original_client_options = deepcopy(client_options) logger = logging.getLogger("esrally.client.factory") - with mock.patch.object(logger, "info") as mocked_info_logger: + with mock.patch.object(logger, "debug") as mocked_debug_logger: f = client.EsClientFactory(hosts, client_options) - mocked_info_logger.assert_has_calls( + mocked_debug_logger.assert_has_calls( [ mock.call("SSL support: on"), mock.call("SSL certificate verification: on"), @@ -149,9 +149,9 @@ def test_create_https_connection_only_verify_self_signed_server_certificate(self original_client_options = deepcopy(client_options) logger = logging.getLogger("esrally.client.factory") - with mock.patch.object(logger, "info") as mocked_info_logger: + with mock.patch.object(logger, "debug") as mocked_debug_logger: f = client.EsClientFactory(hosts, client_options) - mocked_info_logger.assert_has_calls( + mocked_debug_logger.assert_has_calls( [ mock.call("SSL support: on"), mock.call("SSL certificate verification: on"), @@ -220,9 +220,9 @@ def test_create_https_connection_unverified_certificate(self, mocked_load_cert_c original_client_options = dict(client_options) logger = logging.getLogger("esrally.client.factory") - with mock.patch.object(logger, "info") as mocked_info_logger: + with mock.patch.object(logger, "debug") as mocked_debug_logger: f = client.EsClientFactory(hosts, client_options) - mocked_info_logger.assert_has_calls( + mocked_debug_logger.assert_has_calls( [ mock.call("SSL support: on"), mock.call("SSL certificate verification: off"), @@ -261,9 +261,9 @@ def test_create_https_connection_unverified_certificate_present_client_certifica original_client_options = deepcopy(client_options) logger = logging.getLogger("esrally.client.factory") - with mock.patch.object(logger, "info") as mocked_info_logger: + with mock.patch.object(logger, "debug") as mocked_debug_logger: f = client.EsClientFactory(hosts, client_options) - mocked_info_logger.assert_has_calls( + mocked_debug_logger.assert_has_calls( [ mock.call("SSL certificate verification: off"), mock.call("SSL client authentication: on"), diff --git a/tests/driver/scheduler_test.py b/tests/driver/scheduler_test.py index b52f56dec..0ef738762 100644 --- a/tests/driver/scheduler_test.py +++ b/tests/driver/scheduler_test.py @@ -139,12 +139,10 @@ def test_scheduler_does_not_change_throughput_for_empty_requests(self): class TestSchedulerCategorization: class LegacyScheduler: - # pylint: disable=unused-variable def __init__(self, params): pass class LegacySchedulerWithAdditionalArgs: - # pylint: disable=unused-variable def __init__(self, params, my_default_param=True): pass @@ -191,7 +189,6 @@ def test_unthrottled_by_target_interval(self): class TestLegacyWrappingScheduler: class SimpleLegacyScheduler: - # pylint: disable=unused-variable def __init__(self, params): pass