ipulse-shared-core-ftredge 2.57__py3-none-any.whl → 3.1.1__py3-none-any.whl

ipulse_shared_core_ftredge/utils_gcp_for_pipelines.py

@@ -1,201 +0,0 @@
-# pylint: disable=missing-module-docstring
-# pylint: disable=missing-function-docstring
-# pylint: disable=missing-class-docstring
-# pylint: disable=broad-exception-caught
-# pylint: disable=line-too-long
-# pylint: disable=unused-variable
-import json
-import os
-import time
-from ipulse_shared_core_ftredge.enums.enums_common_utils import LogLevel
-from .utils_custom_logs import ContextLog
-from ipulse_shared_core_ftredge.utils_pipelinemon import Pipelinemon
-
-############################################################################
-##################### SETTING UP LOGGER ##########################
-
-####DEPCREACATED: THIS APPROACH WAS GOOD, BUT ERRORS WERE NOT REPORTED TO ERROR REPORTING
-# logging.basicConfig(level=logging.INFO)
-# logging_client = google.cloud.logging.Client()
-# logging_client.setup_logging()
-###################################
-
-
-##### THIS APPROACH IS USED NOW ########
-ENV = os.getenv('ENV', 'LOCAL').strip("'")
-
-
-def write_json_to_gcs_in_pipeline( pipelinemon:Pipelinemon, storage_client, data, bucket_name, file_name,
-                      file_exists_if_starts_with_prefix:str=None, overwrite_if_exists:bool=False, increment_if_exists:bool=False,
-                      save_locally:bool=False, local_path=None,  max_retries:int=2, max_deletable_files:int=1):
-    """Saves data to Google Cloud Storage and optionally locally.
-    
-    This function attempts to upload data to GCS. 
-    - If the upload fails after retries and `save_locally` is True or `local_path` is provided, it attempts to save the data locally.
-    - It handles file name conflicts based on these rules:
-        - If `overwrite_if_exists` is True: 
-            - If `file_exists_if_contains_substr` is provided, ANY existing file containing the substring is deleted, and the new file is saved with the provided `file_name`.
-            - If `file_exists_if_contains_substr` is None, and a file with the exact `file_name` exists, it's overwritten.
-        - If `increment_if_exists` is True:
-            - If `file_exists_if_contains_substr` is provided, a new file with an incremented version is created ONLY if a file with the EXACT `file_name` exists.
-            - If `file_exists_if_contains_substr` is None, a new file with an incremented version is created if a file with the exact `file_name` exists. 
-            
-        -If both overwrite_if_exists and increment_if_exists are provided as Ture, an exception will be raised.
-    """
-
-    with pipelinemon.context("write_json_to_gcs_in_pipeline"):
-        # GCS upload exception
-        gcs_upload_error = False
-        # Input validation
-        if overwrite_if_exists and increment_if_exists:
-            pipelinemon.add_log(ContextLog(LogLevel.ERROR_CUSTOM, subject="Param validation", description="Both 'overwrite_if_exists' and 'increment_if_exists' cannot be True simultaneously."))
-            gcs_upload_error=True
-        if not isinstance(data, (list, dict, str)):
-            pipelinemon.add_log(ContextLog(LogLevel.ERROR_CUSTOM,subject="Data validation", description="Unsupported data type. Data must be a list, dict, or str."))
-            gcs_upload_error=True
-        if max_deletable_files > 10:
-            pipelinemon.add_log(ContextLog(LogLevel.ERROR_CUSTOM,subject="max_deletable_files", description="max_deletable_files should be less than 10 for safety. For more use another method."))
-            gcs_upload_error=True
-
-        # Prepare data
-        if isinstance(data, (list, dict)):
-            data_str = json.dumps(data, indent=2)
-        else:
-            data_str = data
-
-        bucket = storage_client.bucket(bucket_name)
-        base_file_name, ext = os.path.splitext(file_name)
-        increment = 0
-        attempts = 0
-        success = False
-
-        # GCS-related metadata
-        gcs_path = None
-        gcs_file_overwritten = False
-        gcs_file_already_exists = False
-        gcs_file_saved_with_increment = False
-        gcs_file_exists_checked_on_name = file_name
-        gcs_deleted_files=[]
-
-        # Local file path
-        local_path_final = None
-
-        try:
-            upload_allowed = True
-            # --- Overwrite Logic ---
-            if overwrite_if_exists:
-                with pipelinemon.context("overwriting"):
-                    if file_exists_if_starts_with_prefix:
-                        gcs_file_exists_checked_on_name = file_exists_if_starts_with_prefix
-                        blobs_to_delete = list(bucket.list_blobs(prefix=file_exists_if_starts_with_prefix))
-                        if len(blobs_to_delete) > max_deletable_files:
-                            pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_exists_if_starts_with_prefix, description=f"Prefix matched with {len(blobs_to_delete)} files in bucket {bucket_name}"))
-                            #### Ensuring to quit the operation if too many files are found
-                            raise Exception(f"Error: Attempt to delete {len(blobs_to_delete)} matched files, but limit is {max_deletable_files}.")
-                        if blobs_to_delete:
-                            gcs_file_already_exists = True
-                            pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_exists_if_starts_with_prefix, description=f"Prefix matched with {len(blobs_to_delete)} files in bucket {bucket_name}"))
-                            for blob in blobs_to_delete:
-                                gcs_path_del = f"gs://{bucket_name}/{blob.name}"
-                                pipelinemon.add_system_impacted(f"delete: gcs_bucket_file: {gcs_path_del}")
-                                blob.delete()
-                                pipelinemon.add_log(ContextLog(LogLevel.INFO_REMOTE_DELETE_COMPLETE, subject= gcs_path_del, description="file deleted from GCS as part of overwrite, matched with prefix"))
-                                gcs_deleted_files.append(blob.name)
-                            gcs_file_overwritten = True
-                    else:
-                        blob = bucket.blob(file_name)
-                        if blob.exists():
-                            gcs_file_already_exists = True
-                            pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_name, description=f"Exact name matched with existing file in bucket {bucket_name}"))
-                            gcs_path_del = f"gs://{bucket_name}/{file_name}"
-                            pipelinemon.add_system_impacted(f"delete: gcs_bucket_file: {gcs_path_del}")
-                            blob.delete()  # Delete the existing blob
-                            pipelinemon.add_log(ContextLog(LogLevel.INFO_REMOTE_DELETE_COMPLETE, subject= gcs_path_del, description="file deleted from GCS as part of overwrite, matched with exact name"))
-                            gcs_deleted_files.append(blob.name)
-                            gcs_file_overwritten = True
-
-            # --- Increment Logic ---
-            elif increment_if_exists:
-                with pipelinemon.context("incrementing"):
-                    gcs_file_exists_checked_on_name = file_name  # We only increment if the exact name exists
-                    while bucket.blob(file_name).exists():
-                        gcs_file_already_exists = True
-                        increment += 1
-                        file_name = f"{base_file_name}_v{increment}{ext}"
-                        gcs_file_saved_with_increment = True
-                    if increment>0:
-                        pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_name, description=f"File saved with incremented version in {bucket_name}"))
-
-             # --- Check for Conflicts (Including Prefix) ---
-            else:
-                if file_exists_if_starts_with_prefix:
-                    blobs_matched = list(bucket.list_blobs(prefix=file_exists_if_starts_with_prefix))
-                    if blobs_matched:
-                        upload_allowed = False
-                        pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_exists_if_starts_with_prefix, description=f"Prefix matched with {len(blobs_matched)} existing files in bucket {bucket_name}."))
-                    elif bucket.blob(file_name).exists():
-                        pipelinemon.add_log(ContextLog(LogLevel.NOTICE_ALREADY_EXISTS, subject=file_name, description=f"Exact name matched with existing file in bucket {bucket_name}."))
-                        upload_allowed = False
-
-            # --- GCS Upload ---
-            if overwrite_if_exists or increment_if_exists or upload_allowed:
-                with pipelinemon.context("uploading"):
-                    while attempts < max_retries and not success:
-                        try:
-                            gcs_path = f"gs://{bucket_name}/{file_name}"
-                            blob = bucket.blob(file_name)  # Use the potentially updated file_name
-                            pipelinemon.add_system_impacted(f"upload: gcs_bucket_file: {gcs_path}")
-                            blob.upload_from_string(data_str, content_type='application/json')
-                            pipelinemon.add_log(ContextLog(LogLevel.INFO_REMOTE_PERSISTNACE_COMPLETE, subject= gcs_path, description="file uploaded to GCS"))
-                            success = True
-                        except Exception as e:
-                            attempts += 1
-                            if attempts < max_retries:
-                                time.sleep(2 ** attempts)
-                            else:
-                                pipelinemon.add_log(ContextLog(LogLevel.ERROR_EXCEPTION, e=e))
-                                gcs_upload_error = True
-
-        except Exception as e:
-            pipelinemon.add_log(ContextLog(LogLevel.ERROR_EXCEPTION, e=e))
-            gcs_upload_error = True
-
-        # --- Save Locally ---
-        ###### Not logging the local save operation in pipeline, as it is not a critical operation
-        write_out=False
-        if not success or gcs_upload_error or save_locally or local_path:
-            try:
-                local_path=local_path if local_path else "/tmp"
-                local_path_final = os.path.join(local_path, file_name)
-
-                if os.path.exists(local_path_final):
-                    if increment_if_exists:
-                        increment = 0
-                        while os.path.exists(local_path_final):
-                            increment += 1
-                            local_path_final = os.path.join(local_path, f"{base_file_name}_v{increment}{ext}")
-                        write_out=True
-                    elif overwrite_if_exists:
-                        write_out=True
-                    else:
-                        write_out=False
-                else:
-                    write_out=True
-
-                if write_out:
-                    with open(local_path_final, 'w', encoding='utf-8') as f:
-                        f.write(data_str)
-
-            except Exception as local_e:
-                pipelinemon.add_log(ContextLog(LogLevel.WARNING_FIX_RECOMMENDED, e=local_e, description="Failed to write to local file"))
-
-        # --- Return Metadata ---
-        return {
-            "gcs_path": gcs_path if success else None,  # Only set gcs_path if upload succeeded
-            "local_path": local_path_final if write_out else None,  # Only set local_path if saved locally
-            "gcs_file_already_exists": gcs_file_already_exists,
-            "gcs_file_exists_checked_on_name":gcs_file_exists_checked_on_name ,
-            "gcs_file_overwritten": gcs_file_overwritten,
-            "gcs_deleted_file_names": ",,,".join(gcs_deleted_files) if gcs_deleted_files else None,
-            "gcs_file_saved_with_increment": gcs_file_saved_with_increment
-        }

ipulse_shared_core_ftredge/utils_pipelinemon.py

@@ -1,362 +0,0 @@
-# pylint: disable=missing-module-docstring
-# pylint: disable=missing-function-docstring
-# pylint: disable=logging-fstring-interpolation
-# pylint: disable=line-too-long
-# pylint: disable=missing-class-docstring
-# pylint: disable=broad-exception-caught
-import json
-import uuid
-from datetime import datetime, timezone
-from contextlib import contextmanager
-from typing import List
-from google.cloud import logging as cloudlogging
-from ipulse_shared_core_ftredge.enums.enums_common_utils import TargetLogs, LogLevel
-from ipulse_shared_core_ftredge.utils_gcp import write_json_to_gcs
-from ipulse_shared_core_ftredge.utils_custom_logs import ContextLog
-
-
-class Pipelinemon:
-    ERROR_START_CODE = LogLevel.ERROR.value
-    WARNING_START_CODE = LogLevel.WARNING.value
-    NOTICE_START_CODE = LogLevel.NOTICE.value
-    SUCCESS_START_CODE = LogLevel.SUCCESS.value
-    INFO_START_CODE = LogLevel.INFO.value
-
-    def __init__(self, base_context: str, target_logs: TargetLogs = TargetLogs.MIXED, logger_name=None, max_log_field_size:int =10000, max_log_dict_size:float=256 * 1024 * 0.80, max_log_traceback_lines:int = 30):
-        self._id = str(uuid.uuid4())
-        self._logs = []
-        self._early_stop = False
-        self._errors_count = 0
-        self._warnings_count = 0
-        self._notices_count = 0
-        self._successes_count = 0
-        self._infos_count = 0
-        self._systems_impacted = []
-        self._by_level_counts = {level.name: 0 for level in LogLevel}
-        self._base_context = base_context
-        self._context_stack = []
-        self._target_logs = target_logs.value
-        self._logger = self._initialize_logger(logger_name)
-        self._max_log_field_size = max_log_field_size
-        self._max_log_dict_size = max_log_dict_size
-        self._max_log_traceback_lines = max_log_traceback_lines
-
-    def _initialize_logger(self, logger_name):
-        if logger_name:
-            logging_client = cloudlogging.Client()
-            return logging_client.logger(logger_name)
-        return None
-
-    @contextmanager
-    def context(self, context):
-        self.push_context(context)
-        try:
-            yield
-        finally:
-            self.pop_context()
-
-    def push_context(self, context):
-        self._context_stack.append(context)
-
-    def pop_context(self):
-        if self._context_stack:
-            self._context_stack.pop()
-
-    @property
-    def current_context(self):
-        return " >> ".join(self._context_stack)
-
-    @property
-    def base_context(self):
-        return self._base_context
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def systems_impacted(self):
-        return self._systems_impacted
-
-    @systems_impacted.setter
-    def systems_impacted(self, list_of_si: List[str]):
-        self._systems_impacted = list_of_si
-
-    def add_system_impacted(self, system_impacted: str):
-        if self._systems_impacted is None:
-            self._systems_impacted = []
-        self._systems_impacted.append(system_impacted)
-
-    def clear_systems_impacted(self):
-        self._systems_impacted = []
-
-    @property
-    def max_log_dict_size(self):
-        return self._max_log_dict_size
-
-    @max_log_dict_size.setter
-    def max_log_dict_size(self, value):
-        self._max_log_dict_size = value
-
-    @property
-    def max_log_field_size(self):
-        return self._max_log_field_size
-
-    @max_log_field_size.setter
-    def max_log_field_size(self, value):
-        self._max_log_field_size = value
-
-    @property
-    def max_log_traceback_lines(self):
-        return self._max_log_traceback_lines
-
-    @max_log_traceback_lines.setter
-    def max_log_traceback_lines(self, value):
-        self._max_log_traceback_lines = value
-
-    @property
-    def early_stop(self):
-        return self._early_stop
-
-    def set_early_stop(self, max_errors_tolerance: int, create_error_log=True, pop_context=False):
-        self._early_stop = True
-        if create_error_log:
-            if pop_context:
-                self.pop_context()
-            self.add_log(ContextLog(level=LogLevel.ERROR_PIPELINE_THRESHOLD_REACHED,
-                                    subject="EARLY_STOP",
-                                    description=f"Total MAX_ERRORS_TOLERANCE of {max_errors_tolerance} has been reached."))
-
-    def reset_early_stop(self):
-        self._early_stop = False
-
-
-    def add_log(self, log: ContextLog ):
-        if (self._target_logs == TargetLogs.SUCCESSES and log.level >=self.NOTICE_START_CODE) or \
-           (self._target_logs == TargetLogs.WARNINGS_AND_ERRORS and log.level.value < self.WARNING_START_CODE):
-            raise ValueError(f"Invalid log level {log.level.name} for Pipelinemon target logs setup: {self._target_logs}")
-        log.base_context = self.base_context
-        log.context = self.current_context
-        log.collector_id = self.id
-        log.systems_impacted = self.systems_impacted
-        log_dict = log.to_dict(max_field_len=self.max_log_field_size, size_limit=self.max_log_dict_size, max_traceback_lines=self.max_log_traceback_lines)
-        self._logs.append(log_dict)
-        self._update_counts(log_dict)
-
-        if self._logger:
-            # We specifically want to avoid having an ERROR log level for this structured Pipelinemon reporting, to ensure Errors are alerting on Critical Application Services.
-            # A single ERROR log level can be used for the entire pipeline, which shall be used at the end of the pipeline
-            if log.level.value >= self.WARNING_START_CODE:
-                self._logger.log_struct(log_dict, severity="WARNING")
-            elif log.level.value >= self.NOTICE_START_CODE:
-                self._logger.log_struct(log_dict, severity="NOTICE")
-            else:
-                self._logger.log_struct(log_dict, severity="INFO")
-
-    def add_logs(self, logs: List[ContextLog]):
-        for log in logs:
-            self.add_log(log)
-
-    def clear_logs_and_counts(self):
-        self._logs = []
-        self._errors_count = 0
-        self._warnings_count = 0
-        self._notices_count = 0
-        self._successes_count = 0
-        self._infos_count = 0
-        self._by_level_counts = {level.name: 0 for level in LogLevel}
-
-    def clear_logs(self):
-        self._logs = []
-
-    def get_all_logs(self):
-        return self._logs
-
-    def get_logs_for_level(self, level: LogLevel):
-        return [log for log in self._logs if log["level_code"] == level.value]
-
-    def get_logs_by_str_in_context(self, context_substring: str):
-        return [
-            log for log in self._logs
-            if context_substring in log["context"]
-        ]
-
-    def contains_errors(self):
-        return self._errors_count > 0
-
-    def count_errors(self):
-        return self._errors_count
-
-    def contains_warnings_or_errors(self):
-        return self._warnings_count > 0 or self._errors_count > 0
-
-    def count_warnings_and_errors(self):
-        return self._warnings_count + self._errors_count
-
-    def count_warnings(self):
-        return self._warnings_count
-
-    def count_notices(self):
-        return self._notices_count
-
-    def count_successes(self):
-        return self._successes_count
-
-    def count_successes_with_notice(self):
-        return self.count_logs_by_level(LogLevel.SUCCESS_WITH_NOTICES)
-
-    def count_successes_no_notice(self):
-        return self.count_logs_by_level(LogLevel.SUCCESS)
-
-    def count_infos(self):
-        return self._infos_count
-
-    def count_all_logs(self):
-        return len(self._logs)
-
-    def count_logs_by_level(self, level: LogLevel):
-        return self._by_level_counts.get(level.name, 0)
-
-    def _count_logs(self, context_substring: str, exact_match=False, level_code_min=None, level_code_max=None):
-        return sum(
-            1 for log in self._logs
-            if (log["context"] == context_substring if exact_match else context_substring in log["context"]) and
-               (level_code_min is None or log["level_code"] >= level_code_min) and
-               (level_code_max is None or log["level_code"] <= level_code_max)
-        )
-
-    def count_logs_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True)
-
-    def count_logs_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context)
-
-    def count_logs_by_level_for_current_context(self, level: LogLevel):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=level.value, level_code_max=level.value)
-
-    def count_logs_by_level_for_current_and_nested_contexts(self, level: LogLevel):
-        return self._count_logs(self.current_context, level_code_min=level.value, level_code_max=level.value)
-
-    def count_errors_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.ERROR_START_CODE)
-
-    def count_errors_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.ERROR_START_CODE)
-
-    def count_warnings_and_errors_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.WARNING_START_CODE)
-
-    def count_warnings_and_errors_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.WARNING_START_CODE)
-
-    def count_warnings_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.WARNING_START_CODE, level_code_max=self.ERROR_START_CODE - 1)
-
-    def count_warnings_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.WARNING_START_CODE, level_code_max=self.ERROR_START_CODE - 1)
-
-    def count_notices_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.NOTICE_START_CODE, level_code_max=self.WARNING_START_CODE-1)
-
-    def count_notices_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.NOTICE_START_CODE, level_code_max=self.WARNING_START_CODE-1)
-
-    def count_successes_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.SUCCESS_START_CODE, level_code_max=self.NOTICE_START_CODE-1)
-
-    def count_successes_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.SUCCESS_START_CODE, level_code_max=self.NOTICE_START_CODE-1)
-
-    def count_infos_for_current_context(self):
-        return self._count_logs(self.current_context, exact_match=True, level_code_min=self.INFO_START_CODE, level_code_max=self.SUCCESS_START_CODE-1)
-
-    def count_infos_for_current_and_nested_contexts(self):
-        return self._count_logs(self.current_context, level_code_min=self.INFO_START_CODE, level_code_max=self.SUCCESS_START_CODE-1)
-
-    def export_logs_to_gcs_file(self, bucket_name, storage_client, file_prefix=None, file_name=None, top_level_context=None, save_locally=False, overwrite_if_exists=False, increment_if_exists=True, local_path=None, logger=None, max_retries=2):
-        def log_message(message):
-            if logger:
-                logger.info(message)
-
-        def log_error(message, exc_info=False):
-            if logger:
-                logger.error(message, exc_info=exc_info)
-
-        if not file_prefix:
-            file_prefix = self._target_logs
-        if not file_name:
-            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            if top_level_context:
-                file_name = f"{file_prefix}_{timestamp}_{top_level_context}_len{len(self._logs)}.json"
-            else:
-                file_name = f"{file_prefix}_{timestamp}_len{len(self._logs)}.json"
-
-        result = None
-        try:
-            result = write_json_to_gcs(
-                bucket_name=bucket_name,
-                storage_client=storage_client,
-                data=self._logs,
-                file_name=file_name,
-                save_locally=save_locally,
-                local_path=local_path,
-                logger=logger,
-                max_retries=max_retries,
-                overwrite_if_exists=overwrite_if_exists,
-                increment_if_exists=increment_if_exists
-
-            )
-            log_message(f"{file_prefix} successfully saved (overwritten={result.get('gcs_file_overwritten')}, incremented={result.get('gcs_file_saved_with_increment')}) to GCS at {result.get('gcs_path')} and locally at {result.get('local_path')}.")
-        except Exception as e:
-            log_error(f"Failed at export_logs_to_gcs_file for {file_prefix} for file {file_name} to bucket {bucket_name}: {type(e).__name__} - {str(e)}")
-
-        return result
-
-    def import_logs_from_json(self, json_or_file, logger=None):
-        def log_message(message):
-            if logger:
-                logger.info(message)
-
-        def log_warning(message, exc_info=False):
-            if logger:
-                logger.warning(message, exc_info=exc_info)
-
-        try:
-            if isinstance(json_or_file, str):  # Load from string
-                imported_logs = json.loads(json_or_file)
-            elif hasattr(json_or_file, 'read'):  # Load from file-like object
-                imported_logs = json.load(json_or_file)
-            self.add_logs(imported_logs)
-            log_message("Successfully imported logs from json.")
-        except Exception as e:
-            log_warning(f"Failed to import logs from json: {type(e).__name__} - {str(e)}", exc_info=True)
-
-    def _update_counts(self, log, remove=False):
-        level_code = log["level_code"]
-        level_name = log["level_name"]
-
-        if remove:
-            if level_code >= self.ERROR_START_CODE:
-                self._errors_count -= 1
-            elif self.WARNING_START_CODE <= level_code < self.ERROR_START_CODE:
-                self._warnings_count -= 1
-            elif self.NOTICE_START_CODE <= level_code < self.WARNING_START_CODE:
-                self._notices_count -= 1
-            elif self.SUCCESS_START_CODE <= level_code < self.NOTICE_START_CODE:
-                self._successes_count -= 1
-            elif self.INFO_START_CODE <= level_code < self.SUCCESS_START_CODE:
-                self._infos_count -= 1
-            self._by_level_counts[level_name] -= 1
-        else:
-            if level_code >= self.ERROR_START_CODE:
-                self._errors_count += 1
-            elif self.WARNING_START_CODE <= level_code < self.ERROR_START_CODE:
-                self._warnings_count += 1
-            elif self.NOTICE_START_CODE <= level_code < self.WARNING_START_CODE:
-                self._notices_count += 1
-            elif self.SUCCESS_START_CODE <= level_code < self.NOTICE_START_CODE:
-                self._successes_count += 1
-            elif self.INFO_START_CODE <= level_code < self.SUCCESS_START_CODE:
-                self._infos_count += 1
-            self._by_level_counts[level_name] += 1
-