krkn-lib 5.1.10__py3-none-any.whl → 6.0.0__py3-none-any.whl

krkn_lib/tests/test_safe_logger.py

@@ -0,0 +1,496 @@
+"""
+Comprehensive unit tests for SafeLogger class.
+
+This test suite covers both file-based logging mode (with worker thread)
+and standard logging mode (fallback).
+
+Assisted By: Claude Code
+"""
+
+import os
+import tempfile
+import time
+import unittest
+from unittest.mock import patch
+
+from krkn_lib.utils.safe_logger import SafeLogger
+
+
+class TestSafeLoggerInit(unittest.TestCase):
+    """Test SafeLogger initialization."""
+
+    def test_init_with_filename(self):
+        """Test initialization with filename creates file writer and thread."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            temp_path = f.name
+
+        try:
+            logger = SafeLogger(filename=temp_path)
+
+            # Should have file writer
+            self.assertIsNotNone(logger.filewriter)
+            self.assertFalse(logger.finished)
+            self.assertIsNotNone(logger.queue)
+            self.assertEqual(logger.log_file_name, temp_path)
+
+            # Clean up
+            logger.close()
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+    def test_init_with_filename_and_write_mode(self):
+        """Test initialization with custom write mode."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            temp_path = f.name
+
+        try:
+            logger = SafeLogger(filename=temp_path, write_mode="a")
+
+            self.assertIsNotNone(logger.filewriter)
+            self.assertEqual(logger.log_file_name, temp_path)
+
+            logger.close()
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+    def test_init_without_filename(self):
+        """Test initialization without filename uses standard logging."""
+        logger = SafeLogger()
+
+        # Should not have file writer
+        self.assertIsNone(logger.filewriter)
+        self.assertTrue(logger.finished)
+        self.assertIsNone(logger.log_file_name)
+
+    def test_init_default_write_mode(self):
+        """Test default write mode is w+."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            temp_path = f.name
+
+        try:
+            # Write some initial content
+            with open(temp_path, "w") as f:
+                f.write("initial content\n")
+
+            # Create logger with default mode (w+)
+            logger = SafeLogger(filename=temp_path)
+            logger.close()
+
+            # File should be overwritten (w+ truncates)
+            with open(temp_path, "r") as f:
+                content = f.read()
+                # Should be empty or only contain new logs
+                # NOT "initial content"
+                self.assertNotIn("initial content", content)
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+
+class TestSafeLoggerFileLogging(unittest.TestCase):
+    """Test file-based logging functionality."""
+
+    def setUp(self):
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
+        self.temp_path = self.temp_file.name
+        self.temp_file.close()
+
+    def tearDown(self):
+        if os.path.exists(self.temp_path):
+            os.unlink(self.temp_path)
+
+    def test_error_logs_to_file(self):
+        """Test error() writes to file with [ERR] prefix."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.error("Test error message")
+
+        # Give worker thread time to process
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("[ERR]", content)
+            self.assertIn("Test error message", content)
+
+    def test_warning_logs_to_file(self):
+        """Test warning() writes to file with [WRN] prefix."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.warning("Test warning message")
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("[WRN]", content)
+            self.assertIn("Test warning message", content)
+
+    def test_info_logs_to_file(self):
+        """Test info() writes to file with [INF] prefix."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.info("Test info message")
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("[INF]", content)
+            self.assertIn("Test info message", content)
+
+    def test_multiple_logs_to_file(self):
+        """Test multiple log messages are written in order."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.error("Error 1")
+        logger.warning("Warning 1")
+        logger.info("Info 1")
+        logger.error("Error 2")
+
+        time.sleep(0.2)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            lines = content.strip().split("\n")
+
+            # Should have 4 lines
+            self.assertEqual(len(lines), 4)
+
+            # Check order and prefixes
+            self.assertIn("[ERR]", lines[0])
+            self.assertIn("Error 1", lines[0])
+            self.assertIn("[WRN]", lines[1])
+            self.assertIn("Warning 1", lines[1])
+            self.assertIn("[INF]", lines[2])
+            self.assertIn("Info 1", lines[2])
+            self.assertIn("[ERR]", lines[3])
+            self.assertIn("Error 2", lines[3])
+
+    def test_timestamp_in_logs(self):
+        """Test log messages include timestamp."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.info("Test message")
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            # Timestamp format: YYYY-MM-DD HH:MM
+            # Check for date pattern (at least year)
+            import datetime
+
+            current_year = datetime.datetime.now().year
+            self.assertIn(str(current_year), content)
+
+    def test_close_waits_for_queue(self):
+        """Test close() waits for all messages to be processed."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        # Queue multiple messages
+        for i in range(10):
+            logger.info(f"Message {i}")
+
+        # Close should wait for all messages
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            lines = content.strip().split("\n")
+
+            # All 10 messages should be written
+            self.assertEqual(len(lines), 10)
+
+    def test_log_file_name_property(self):
+        """Test log_file_name property returns filename."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        self.assertEqual(logger.log_file_name, self.temp_path)
+
+        logger.close()
+
+    def test_append_mode(self):
+        """Test append mode preserves existing content."""
+        # Write initial content
+        with open(self.temp_path, "w") as f:
+            f.write("Initial line\n")
+
+        # Create logger with append mode
+        logger = SafeLogger(filename=self.temp_path, write_mode="a")
+        logger.info("Appended message")
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("Initial line", content)
+            self.assertIn("Appended message", content)
+
+
+class TestSafeLoggerStandardLogging(unittest.TestCase):
+    """Test standard logging fallback (no file)."""
+
+    @patch("logging.error")
+    def test_error_uses_logging_when_no_file(self, mock_error):
+        """Test error() uses logging.error when no file specified."""
+        logger = SafeLogger()
+
+        logger.error("Test error")
+
+        mock_error.assert_called_once_with("Test error")
+
+    @patch("logging.warning")
+    def test_warning_uses_logging_when_no_file(self, mock_warning):
+        """Test warning() uses logging.warning when no file specified."""
+        logger = SafeLogger()
+
+        logger.warning("Test warning")
+
+        mock_warning.assert_called_once_with("Test warning")
+
+    @patch("logging.info")
+    def test_info_uses_logging_when_no_file(self, mock_info):
+        """Test info() uses logging.info when no file specified."""
+        logger = SafeLogger()
+
+        logger.info("Test info")
+
+        mock_info.assert_called_once_with("Test info")
+
+    @patch("logging.error")
+    @patch("logging.warning")
+    @patch("logging.info")
+    def test_multiple_logs_use_logging(
+        self, mock_info, mock_warning, mock_error
+    ):
+        """Test multiple calls use standard logging."""
+        logger = SafeLogger()
+
+        logger.error("Error message")
+        logger.warning("Warning message")
+        logger.info("Info message")
+
+        mock_error.assert_called_once_with("Error message")
+        mock_warning.assert_called_once_with("Warning message")
+        mock_info.assert_called_once_with("Info message")
+
+
+class TestSafeLoggerAfterClose(unittest.TestCase):
+    """Test behavior after close() is called."""
+
+    def setUp(self):
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
+        self.temp_path = self.temp_file.name
+        self.temp_file.close()
+
+    def tearDown(self):
+        if os.path.exists(self.temp_path):
+            os.unlink(self.temp_path)
+
+    @patch("logging.error")
+    def test_error_uses_logging_after_close(self, mock_error):
+        """Test error() uses logging after close()."""
+        logger = SafeLogger(filename=self.temp_path)
+        logger.close()
+
+        # After close, finished is True, should use standard logging
+        logger.error("After close error")
+
+        mock_error.assert_called_once_with("After close error")
+
+    @patch("logging.warning")
+    def test_warning_uses_logging_after_close(self, mock_warning):
+        """Test warning() uses logging after close()."""
+        logger = SafeLogger(filename=self.temp_path)
+        logger.close()
+
+        logger.warning("After close warning")
+
+        mock_warning.assert_called_once_with("After close warning")
+
+    @patch("logging.info")
+    def test_info_uses_logging_after_close(self, mock_info):
+        """Test info() uses logging after close()."""
+        logger = SafeLogger(filename=self.temp_path)
+        logger.close()
+
+        logger.info("After close info")
+
+        mock_info.assert_called_once_with("After close info")
+
+
+class TestSafeLoggerWorkerThread(unittest.TestCase):
+    """Test worker thread functionality."""
+
+    def setUp(self):
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
+        self.temp_path = self.temp_file.name
+        self.temp_file.close()
+
+    def tearDown(self):
+        if os.path.exists(self.temp_path):
+            os.unlink(self.temp_path)
+
+    def test_worker_thread_is_daemon(self):
+        """Test worker thread is created as daemon."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        # Worker thread should be running
+        import threading
+
+        threads = [
+            t for t in threading.enumerate() if t.name == "SafeLogWriter"
+        ]
+        # Should have at least one SafeLogWriter thread
+        self.assertGreater(len(threads), 0)
+        # All SafeLogWriter threads should be daemon threads
+        for thread in threads:
+            self.assertTrue(thread.daemon)
+
+        logger.close()
+
+    def test_worker_thread_processes_queue(self):
+        """Test worker thread processes messages from queue."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        # Add messages
+        logger._write("Direct message 1")
+        logger._write("Direct message 2")
+
+        # Wait for processing
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("Direct message 1", content)
+            self.assertIn("Direct message 2", content)
+
+    def test_worker_stops_when_finished(self):
+        """Test worker thread stops when finished flag is set."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.info("Test message")
+        time.sleep(0.1)
+
+        # Close sets finished to True
+        logger.close()
+
+        # Wait a bit for thread to finish
+        time.sleep(0.1)
+
+        # Worker thread should have stopped
+        import threading
+
+        [t for t in threading.enumerate() if t.name == "SafeLogWriter"]
+        # Thread may still exist briefly, but should not be processing
+        self.assertTrue(logger.finished)
+
+
+class TestSafeLoggerEdgeCases(unittest.TestCase):
+    """Test edge cases and error conditions."""
+
+    def setUp(self):
+        self.temp_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
+        self.temp_path = self.temp_file.name
+        self.temp_file.close()
+
+    def tearDown(self):
+        if os.path.exists(self.temp_path):
+            os.unlink(self.temp_path)
+
+    def test_empty_message(self):
+        """Test logging empty string."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        logger.info("")
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            # Should have timestamp and prefix, even if message is empty
+            self.assertIn("[INF]", content)
+
+    def test_multiline_message(self):
+        """Test logging multiline message."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        multiline = "Line 1\nLine 2\nLine 3"
+        logger.info(multiline)
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("Line 1", content)
+            self.assertIn("Line 2", content)
+            self.assertIn("Line 3", content)
+
+    def test_special_characters(self):
+        """Test logging messages with special characters."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        special_msg = "Test with émojis 🎉 and spëcial çhars: @#$%^&*()"
+        logger.info(special_msg)
+
+        time.sleep(0.1)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("Test with", content)
+            # Special characters may or may not be preserved based on encoding
+
+    def test_very_long_message(self):
+        """Test logging very long message."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        long_msg = "A" * 10000
+        logger.info(long_msg)
+
+        time.sleep(0.2)
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            self.assertIn("A" * 100, content)  # Check partial content
+
+    def test_rapid_logging(self):
+        """Test rapid successive logging."""
+        logger = SafeLogger(filename=self.temp_path)
+
+        # Log 100 messages rapidly
+        for i in range(100):
+            logger.info(f"Message {i}")
+
+        logger.close()
+
+        with open(self.temp_path, "r") as f:
+            content = f.read()
+            lines = content.strip().split("\n")
+
+            # All messages should be written
+            self.assertEqual(len(lines), 100)
+
+    @patch("logging.info")
+    def test_log_file_name_none_when_no_file(self, mock_info):
+        """Test log_file_name is None when using standard logging."""
+        logger = SafeLogger()
+
+        self.assertIsNone(logger.log_file_name)
+
+
+if __name__ == "__main__":
+    unittest.main()

krkn_lib/tests/test_utils.py

@@ -29,11 +29,10 @@ class UtilFunctionTests(BaseTest):
         test_workdir = os.path.join(workdir_basepath, workdir)
         os.mkdir(test_workdir)
         test_string = "Tester McTesty!"
-        with tempfile.NamedTemporaryFile(
-            dir=test_workdir
-        ) as src, tempfile.NamedTemporaryFile(
-            dir=test_workdir
-        ) as dst:  # NOQA
+        with (
+            tempfile.NamedTemporaryFile(dir=test_workdir) as src,
+            tempfile.NamedTemporaryFile(dir=test_workdir) as dst,
+        ):  # NOQA
             with open(src.name, "w+") as source, open(dst.name, "w+") as dest:
                 encoded_test_byte = base64.b64encode(
                     test_string.encode("utf-8")

krkn_lib/utils/functions.py

@@ -25,9 +25,10 @@ def decode_base64_file(source_filename: str, destination_filename: str):
     :param source_filename: source base64 encoded file
     :param destination_filename: destination decoded file
     """
-    with open(source_filename, "rb") as encoded_source, open(
-        destination_filename, "wb"
-    ) as target:
+    with (
+        open(source_filename, "rb") as encoded_source,
+        open(destination_filename, "wb") as target,
+    ):
         with Base64IO(encoded_source) as source:
             for line in source:
                 target.write(line)

krkn_lib/version/version.py

@@ -1,3 +1,6 @@
-import importlib.metadata
+try:
+    import importlib_metadata
+except ImportError:
+    import importlib.metadata as importlib_metadata
 
-__version__ = importlib.metadata.version("krkn-lib")
+__version__ = importlib_metadata.version("krkn-lib")

{krkn_lib-5.1.10.dist-info → krkn_lib-6.0.0.dist-info}/METADATA

@@ -1,26 +1,24 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: krkn-lib
-Version: 5.1.10
+Version: 6.0.0
 Summary: Foundation library for Kraken
+Home-page: https://github.com/redhat-chaos/krkn
 License: Apache-2.0
-License-File: LICENSE
 Author: Red Hat Chaos Team
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: PyYAML (==6.0.1)
 Requires-Dist: base64io (>=1.0.3,<2.0.0)
 Requires-Dist: coverage (>=7.6.12,<8.0.0)
 Requires-Dist: cython (==3.0)
 Requires-Dist: deprecation (==2.1.0)
-Requires-Dist: elasticsearch (==8.19.1)
-Requires-Dist: elasticsearch-dsl (==8.18.0)
+Requires-Dist: elasticsearch (==7.13.4)
+Requires-Dist: elasticsearch-dsl (==7.4.1)
+Requires-Dist: importlib-metadata (>=8.7.0,<9.0.0)
 Requires-Dist: kubeconfig (>=1.1.1,<2.0.0)
 Requires-Dist: kubernetes (==34.1.0)
 Requires-Dist: numpy (==1.26.4)
@@ -31,7 +29,6 @@ Requires-Dist: sphinx-rtd-theme (>=1.2.2,<2.0.0)
 Requires-Dist: sphinxnotes-markdown-builder (>=0.5.6,<0.6.0)
 Requires-Dist: tzlocal (==5.1)
 Requires-Dist: wheel (>=0.42.0,<0.43.0)
-Project-URL: Homepage, https://github.com/redhat-chaos/krkn
 Description-Content-Type: text/markdown
 
 ![action](https://github.com/krkn-chaos/krkn-lib/actions/workflows/build.yaml/badge.svg)

{krkn_lib-5.1.10.dist-info → krkn_lib-6.0.0.dist-info}/RECORD

@@ -1,63 +1,67 @@
 krkn_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-krkn_lib/aws_tests/__init__.py,sha256=vAyS1U3V-MTOqLgwlAK5W_gIT3VDxDrNzMRpaYe9fME,39
+krkn_lib/aws_tests/__init__.py,sha256=NZrpL92E1-yoKE7HrwONb0zfqO-XaIt9iI5iLMKHhww,40
 krkn_lib/aws_tests/test_krkn_telemetry_kubernetes.py,sha256=VxE0MMo6pTVJj2iTJYs0Ei_jbVxOVXpupFLXrnlf02M,12633
 krkn_lib/aws_tests/test_krkn_telemetry_openshift.py,sha256=AE6nwWi2c2WqjU4mQ2Kr1XGr5FcmFbvaZALDDHpaEMQ,2151
 krkn_lib/elastic/__init__.py,sha256=ApLS0O18jzfu1Oe6Ym7XYlC1bFl9JTYO6VjFQflDlA0,36
-krkn_lib/elastic/krkn_elastic.py,sha256=YeZqEV61-icQTVrgA_0hDgD5L0zFmM3vmX_m7hXYOJU,8954
+krkn_lib/elastic/krkn_elastic.py,sha256=W4qgwN0Tca2VhYHSP7CBa4kaVbN6fXHg0WzbBrBCz3E,8985
 krkn_lib/k8s/__init__.py,sha256=umPTRrPgLUdtHf9epWNcQaA7p9d3gZFtFiXQw36Pqug,39
-krkn_lib/k8s/krkn_kubernetes.py,sha256=ikfhqGeKWcaopOPkpTL00XdJS71F0p6fB86mc0v8Gs8,113564
-krkn_lib/k8s/pod_monitor/__init__.py,sha256=QTdgv_mOqlB8ViVMRYWCPN0FxG5abxZoCeFUNqGfM3A,351
-krkn_lib/k8s/pod_monitor/pod_monitor.py,sha256=ICWsbLtgBfqjJy-oUGDdEJKp66rq6DjOv1xUPcaay3A,10693
+krkn_lib/k8s/krkn_kubernetes.py,sha256=8EMwCDVCjgqYC7MxIGGasvcyaYF2TFFV5XSotc0Ng-0,127534
+krkn_lib/k8s/pod_monitor/__init__.py,sha256=XDppIzqucShXUTeq2KgP6iQoC4pHmBlI6VcTNOxekEo,350
+krkn_lib/k8s/pod_monitor/pod_monitor.py,sha256=k_e49grzKR1CuG4aFU9jYcTsIrDw9Lmih3rKnpJ8Xhw,14353
 krkn_lib/k8s/templates/hog_pod.j2,sha256=PloumCIFkLpZCJPwNRf5kwcAfLH12AXNepQjdn942Wc,1650
 krkn_lib/k8s/templates/node_exec_pod.j2,sha256=hj0yryqooF8eZPdoC7-_4kF5OCvPagfItuRO4PhevaI,558
 krkn_lib/k8s/templates/service_hijacking_config_map.j2,sha256=Ma9W640yR-sRf9VgC5ha_enRjc-I1NAeAtNg4fglJAg,146
 krkn_lib/k8s/templates/service_hijacking_pod.j2,sha256=urksFQ0RBqnux3gl7exEjQi-XjhhXXdNn2shhBYDl-Y,762
+krkn_lib/k8s/templates/snapshot.j2,sha256=-ap0QiDxy8ZVi7wvQsmqVNvW8RCHesV2sZSuhXQnFFw,212
 krkn_lib/k8s/templates/syn_flood_pod.j2,sha256=ANCEhFZP6yzChGK52_01mV2k6cIb0JNR9ocSFHpxPT0,1132
 krkn_lib/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 krkn_lib/models/elastic/__init__.py,sha256=B5B2XDHj9grxPBwcGm2SCXAyqtJHkywwDUFPvmrh_H4,30
-krkn_lib/models/elastic/models.py,sha256=eb4j4H03O4X-X8ZOyWAifibGR1tEYs3kowV243qs5L0,8721
+krkn_lib/models/elastic/models.py,sha256=abjWPCxJoZWk08mHoaFKmpGHSXQZZ4tAbsBCxmYoYlQ,9709
 krkn_lib/models/k8s/__init__.py,sha256=B5B2XDHj9grxPBwcGm2SCXAyqtJHkywwDUFPvmrh_H4,30
-krkn_lib/models/k8s/models.py,sha256=NOscNnO9MumRS69gAUos8hXxB34aFv0YXNb9TPsgrPw,9846
+krkn_lib/models/k8s/models.py,sha256=Q2QIbVt8EIW1zX1khf_fY0-gMbzVmAC3IXA00H9fpBc,9848
 krkn_lib/models/krkn/__init__.py,sha256=B5B2XDHj9grxPBwcGm2SCXAyqtJHkywwDUFPvmrh_H4,30
 krkn_lib/models/krkn/models.py,sha256=npVBsyog_cPrGVHyDzdkAXhkmGlpsusSM_q9nCyN5rE,6762
 krkn_lib/models/pod_monitor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-krkn_lib/models/pod_monitor/models.py,sha256=MbBKwXV-dZxtM9wYp0ELLX_WIV3oysoMpZCuMKqONBo,8763
+krkn_lib/models/pod_monitor/models.py,sha256=a2bGdrVYouO8I1v68Bv25nQYXjLnR3T23dCZUNxRpE4,8763
 krkn_lib/models/telemetry/__init__.py,sha256=B5B2XDHj9grxPBwcGm2SCXAyqtJHkywwDUFPvmrh_H4,30
-krkn_lib/models/telemetry/models.py,sha256=BJNIachnIRXCvA8scyvVBo2OEE-NwGb8OjSnp6G7cQ8,18684
+krkn_lib/models/telemetry/models.py,sha256=d9AGLWWIXVSvdMG3LdjAKfWze5AXgqFuhAFY0KPoPik,18988
 krkn_lib/ocp/__init__.py,sha256=CmweI-5lweWd8wG3q0y9m2ENAr9xvC7aldoJkjC3PQQ,38
-krkn_lib/ocp/krkn_openshift.py,sha256=8bUnJlkC1Yy2euWeOAPrXTCE22r6M8b0__g4NLhuaY4,17904
+krkn_lib/ocp/krkn_openshift.py,sha256=bjjT4vgSiYgYyl8djMyF5kd6AfVl_rmDk3J71ATMITk,17896
 krkn_lib/prometheus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-krkn_lib/prometheus/krkn_prometheus.py,sha256=vulbna0FIxcKtt1BlnE4FEU84Zmw31RiQSItm1Xxehs,8894
+krkn_lib/prometheus/krkn_prometheus.py,sha256=SBHYwvL-GlYdGVS2Ny7nwMUCYwxGKOGnkXtJN52szyI,8895
 krkn_lib/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 krkn_lib/telemetry/k8s/__init__.py,sha256=HTC3-41WJaqtHNyRSzUC-SiLnrgshLKEAyFwMdVVTgU,49
-krkn_lib/telemetry/k8s/krkn_telemetry_kubernetes.py,sha256=dglDCGwbYc1HjiMCV01qHJuclzty4Y71fFtLOv1y92I,24635
+krkn_lib/telemetry/k8s/krkn_telemetry_kubernetes.py,sha256=sYMt4MPpBkj4NYWvsLK7-6yjSBcEV_Wx0Iv7_yhpDIc,24638
 krkn_lib/telemetry/ocp/__init__.py,sha256=DgRL7JxW766o2L8m-E94ftgCdWhsgjURz6gAb9J9Rio,48
-krkn_lib/telemetry/ocp/krkn_telemetry_openshift.py,sha256=rpK-TJfpeJWUEQQgzpeUMhMvv3s1J9FrJtIOTUUPndY,9475
+krkn_lib/telemetry/ocp/krkn_telemetry_openshift.py,sha256=sHEx5B1fvP9ZVSXdc8YXmmB6BUJHVg9uiJ0-CX-0A-8,9473
 krkn_lib/tests/__init__.py,sha256=_-mAJNNBGEod6A8tfckMP9loSOi_Bj4YHvpo93aqHME,33
-krkn_lib/tests/base_test.py,sha256=3z4CMh0e1k0txwU1MyPQhkfn4X-qYiXs7hQcO-f-jDI,22394
+krkn_lib/tests/base_test.py,sha256=3inisgiuJKhyPeszHqRLig3rpCFGozZTet6mdOCVROU,22926
 krkn_lib/tests/test_krkn_elastic.py,sha256=VFNu_NQLXEaq2rFR7BLwtynigVLuw8vhBNEUm53vpII,5612
-krkn_lib/tests/test_krkn_elastic_models.py,sha256=eAl2kA20LWi3Q4eED6sDV8GYvxTy1G5uOhsnfVPOeWw,9303
-krkn_lib/tests/test_krkn_kubernetes_check.py,sha256=z2TJlqMcs208jx6VbF9jTB0DXmTytXIFkZ88nAU8aTU,9403
-krkn_lib/tests/test_krkn_kubernetes_create.py,sha256=QGnO9bwrk_eRyH-4LaEZY6cxu9Qdlcc8CQDxwsnkr5A,2597
-krkn_lib/tests/test_krkn_kubernetes_delete.py,sha256=VXl-NhWrJejwxRhpeyjPVngggQsHeuJ17UfgdXxSF3k,5021
+krkn_lib/tests/test_krkn_elastic_models.py,sha256=zJczdSOU6FMq2y5dnDTv7MP-L6qEzO2wFNbSn9hEY-I,10006
+krkn_lib/tests/test_krkn_kubernetes_check.py,sha256=SbENKhRoWMH5PNY66fDai0_A3qxIsZqXLlm0tzFbp5k,9404
+krkn_lib/tests/test_krkn_kubernetes_create.py,sha256=bFcZ4Z01oyhkeXf7C3XR0Okt-OC89ffmTiaYx6GfkRQ,2599
+krkn_lib/tests/test_krkn_kubernetes_delete.py,sha256=Q3WqyRBbijjcb-Wh_pQD7fjcGHEhUmL0ZexCmiyQNzg,5022
 krkn_lib/tests/test_krkn_kubernetes_exec.py,sha256=BX3x-kSE-HGOZYNEosTDFbeHFBLDhnvyBC9Arai_Bf4,6927
-krkn_lib/tests/test_krkn_kubernetes_get.py,sha256=psTuDuvTTINPNK6Mnn69g9ZKNHKcWJ2fFvw8Kx4g0wI,13064
+krkn_lib/tests/test_krkn_kubernetes_get.py,sha256=cqNXKN8ltbb6veRgSKUlAOUS2Dg3dgJzHYyne-902Zo,13065
 krkn_lib/tests/test_krkn_kubernetes_list.py,sha256=FplPIL-bw5oNaplCsed0tjqlBN7fj2MJN259f1-zjVo,6781
-krkn_lib/tests/test_krkn_kubernetes_misc.py,sha256=W-0I5BPIMVO7E3HMh5WsB1hVjq37uNb2YsX2EcN75AQ,13557
-krkn_lib/tests/test_krkn_kubernetes_models.py,sha256=4iUoLz-m2EHFwFOgGx2HBJ-dwRDhv_8wXSZ5TQd72-U,6291
+krkn_lib/tests/test_krkn_kubernetes_misc.py,sha256=inPzA4zUy14-jfNKlF5zdD-x7Fj28QGEEWffJ3jb5C8,13555
+krkn_lib/tests/test_krkn_kubernetes_models.py,sha256=q3q5N3IV7dQ9Yw1h9zqLjG7F-oayVjel65dK64Pbr5I,6291
 krkn_lib/tests/test_krkn_kubernetes_pods_monitor.py,sha256=x4sfBxMWucNTxVJHR89q2ypVIMxt46iR5Mm6t8O7VMg,21149
-krkn_lib/tests/test_krkn_kubernetes_pods_monitor_models.py,sha256=R3Bn-R6C192xDpIJAZU5NKfn9UN2NCiQEDAbkyu9oBA,12794
-krkn_lib/tests/test_krkn_openshift.py,sha256=ZXHQ8VutqWsjfTdjdvfGGXqNnPL9ByfHKYjkQLkwl1w,4108
+krkn_lib/tests/test_krkn_kubernetes_pods_monitor_models.py,sha256=EktKygoBPeHGNsnVU6PYVfPnrUqP8ELt3dyjY2I36pA,12793
+krkn_lib/tests/test_krkn_kubernetes_virt.py,sha256=X60xb12lmigJRRLDeWJvgpQNS1wffXqm_NhnIYo86Ak,25831
+krkn_lib/tests/test_krkn_openshift.py,sha256=3KjDJm5z7sib6bWJkGj_oiK7hoMBAHtE3lD28Px1bxE,22160
 krkn_lib/tests/test_krkn_prometheus.py,sha256=Yh3rHjomZGke6tgfebGyPt_L6di8a7QplPneTVmd70w,9308
+krkn_lib/tests/test_krkn_telemetry_kubernetes.py,sha256=uA5fJ3aLuAN8KKCYuYaporeQNQ4lMIBcTVR3rA5FdII,29239
 krkn_lib/tests/test_krkn_telemetry_models.py,sha256=J2PI4KAfZ7gSKhPC9DTJtlBKtObf69Kh_WbHcKbK8_Q,16219
-krkn_lib/tests/test_utils.py,sha256=wdOO2blrbGk0r0szQNfgsYWc3UHdyRzD8fwNxyKK4VI,14959
+krkn_lib/tests/test_safe_logger.py,sha256=GDuFGAeA7AjjKGjAYARoqkBWgEkZZQ01Z1cXFkk5alA,15461
+krkn_lib/tests/test_utils.py,sha256=bAV8X69xo3djdd5Y9FRDHPjIn6U9dnikBCGQ4e632Ug,14952
 krkn_lib/tests/test_version.py,sha256=UepvN_1NixumE1mQssrv0G_Fp2bWibtvbDjEgmWoqe0,209
 krkn_lib/utils/__init__.py,sha256=1U4hxrKaKha2eWTrxyrvjNO3bZNoybQAy8Ne_Oglbxc,68
-krkn_lib/utils/functions.py,sha256=H4xA321fp-MzmKV97_n1FYsmqsm3dUw_hex0qHlKjYU,17546
+krkn_lib/utils/functions.py,sha256=DyCHJOt-NzbmUQoFi0U_nyjX1vy4Hu0r_cAlsCZ7nYM,17557
 krkn_lib/utils/safe_logger.py,sha256=NLVy7589hZqrxc-YhkEOhg8GBJ7jxKofAQotiyvyo-4,3687
 krkn_lib/version/__init__.py,sha256=0MLmj0ik-h9IVeq7zw8Xi5ux99DHfxJQ83Iv9Aqiubc,41
-krkn_lib/version/version.py,sha256=pdrCTedp-HDIYnG6e-AwN2nMK8vdbNTioqXxJpIZ6b8,80
-krkn_lib-5.1.10.dist-info/METADATA,sha256=5B1LKQELiAqcE45huoRLHfcH05j2RQMpCQM76Bv4Zjc,2784
-krkn_lib-5.1.10.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-krkn_lib-5.1.10.dist-info/licenses/LICENSE,sha256=DOwG4OVfvD3FzuT8qbYH9my49OTbzzs8ATWU3RVnMuk,10173
-krkn_lib-5.1.10.dist-info/RECORD,,
+krkn_lib/version/version.py,sha256=kOrbxEJIrxXsRb26ONRr_G063pmWi1Sxy6QCYNYB_Pk,161
+krkn_lib-6.0.0.dist-info/LICENSE,sha256=DOwG4OVfvD3FzuT8qbYH9my49OTbzzs8ATWU3RVnMuk,10173
+krkn_lib-6.0.0.dist-info/METADATA,sha256=nTc5rD-rOMkU_rD7thG9gvOqzQE8Yc9UMHMAuAcopXY,2648
+krkn_lib-6.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+krkn_lib-6.0.0.dist-info/RECORD,,