serverish 1.5.0__tar.gz → 2.0.0__tar.gz

{serverish-1.5.0 → serverish-2.0.0}/PKG-INFO

@@ -1,14 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: serverish
-Version: 1.5.0
+Version: 2.0.0
 Summary: helpers for server alike projects
-Home-page: https://github.com/AkondLab/serverish
+License-File: LICENSE
 Author: Mikołaj Kałuszyński
 Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
 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
 Provides-Extra: dns
 Provides-Extra: messenger
 Requires-Dist: aiodns (>=3.2.0,<4.0.0) ; extra == "dns"
@@ -45,9 +47,13 @@ this will install `nats-py` package.
 ## Plans
 - Decorators `@messenger.sub(subject)` (Web framework style)
 - Progress with automatic increment for known durations e.g. `pro_pub.update(completed=1, when=+20)`
-- Pytest fixtures for NATS on CI
+- Custom JetStream API replacing nats-py private internals access
 
 ## Changes
+* 1.7 Subscription reliability: reader auto-recovers from NATS disconnects and consumer expiry,
+  RPC responder auto-resubscribes, `health_status` property on all drivers (reader, publisher,
+  RPC responder, connection) with reconnect counts, error tracking, slow consumer detection.
+  Comprehensive test suite (194 tests) with testcontainers-based NATS fixtures.
 * 1.5 Introduces live documents (`LiveDocument`, `get_documentreader()`, `get_live_document()`) for auto-updating configuration from NATS.
 * 1.4 Contains improvements to the network problems recovery and connection tracking.
 * 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.

{serverish-1.5.0 → serverish-2.0.0}/README.md

@@ -25,9 +25,13 @@ this will install `nats-py` package.
 ## Plans
 - Decorators `@messenger.sub(subject)` (Web framework style)
 - Progress with automatic increment for known durations e.g. `pro_pub.update(completed=1, when=+20)`
-- Pytest fixtures for NATS on CI
+- Custom JetStream API replacing nats-py private internals access
 
 ## Changes
+* 1.7 Subscription reliability: reader auto-recovers from NATS disconnects and consumer expiry,
+  RPC responder auto-resubscribes, `health_status` property on all drivers (reader, publisher,
+  RPC responder, connection) with reconnect counts, error tracking, slow consumer detection.
+  Comprehensive test suite (194 tests) with testcontainers-based NATS fixtures.
 * 1.5 Introduces live documents (`LiveDocument`, `get_documentreader()`, `get_live_document()`) for auto-updating configuration from NATS.
 * 1.4 Contains improvements to the network problems recovery and connection tracking.
 * 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.

{serverish-1.5.0 → serverish-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "serverish"
-version = "1.5.0"
+version = "2.0.0"
 description = "helpers for server alike projects"
 authors = ["Mikołaj Kałuszyński", "MMME team"]
 readme = "README.md"
@@ -20,12 +20,14 @@ dns = ["aiodns"]
 
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^7.4.0"
-pytest-asyncio = "^0.21.0"
+pytest = ">=8.2,<9"
+pytest-asyncio = ">=0.24,<1"
 nats-py = "^2.6.0"
 jupyter = "*"
 rich = "^13.5.2"
 aiodns = "^3.1.1"
+testcontainers = {extras = ["nats"], version = "^4.14.2"}
+pytest-timeout = "^2.4.0"
 
 
 [build-system]

{serverish-1.5.0 → serverish-2.0.0}/serverish/base/__init__.py

@@ -1,4 +1,4 @@
-from .status import Status, StatusEnum
+from .status import Status, StatusReport, aggregate_status
 from .task_manager import create_task, TaskManager, Task
 from .asyncio_util_functions import wait_for_psce
 from .exceptions import *

{serverish-1.5.0 → serverish-2.0.0}/serverish/base/exceptions.py

@@ -18,7 +18,7 @@ class MessengerRequestNoResponders(MessengerRequestNoResponse):
 
 class MessengerRequestJetStreamSubject(MessengerRequestNoResponse):
     def __init__(self, subject:str) -> None:
-        super().__init__(f'Subject {subject} probably declared in JestStream stream. '
+        super().__init__(f'Subject {subject} probably declared in JetStream stream. '
                          f'Use pure NATS core subjects for RPC')
 
 

{serverish-1.5.0 → serverish-2.0.0}/serverish/base/hasstatuses.py

@@ -7,11 +7,11 @@ import param
 
 from serverish.base.collector import Collector
 from serverish.base.manageable import Manageable
-from serverish.base.status import Status, StatusEnum
+from serverish.base.status import Status, StatusReport
 
 logger = logging.getLogger(__name__.rsplit('.')[-1])
 
-CheckMethodType = Callable[[], Union[Awaitable[Status], Status]]
+CheckMethodType = Callable[[], Union[Awaitable[StatusReport], StatusReport]]
 
 class HasStatuses(Manageable):
     """Controls the resource
@@ -23,9 +23,9 @@ class HasStatuses(Manageable):
 
     """
     @staticmethod
-    def diagnose_dummy_ok() -> Status:
-        """Dummy diagnosis, returns StatusEnum.ok"""
-        return Status.new_ok(msg='Dummy OK')
+    def diagnose_dummy_ok() -> StatusReport:
+        """Dummy diagnosis, returns OK status."""
+        return StatusReport.ok(msg='Dummy OK')
 
     status = param.Dict(default={}, doc='A dictionary to hold status information')
 
@@ -68,7 +68,7 @@ class HasStatuses(Manageable):
         else:
             self.check_methods = {**self.check_methods, **methods}
 
-    def set_status(self, key: str, value: Status | None) -> None:
+    def set_status(self, key: str, value: StatusReport | None) -> None:
         """Sets status of the resource
 
         A resource can have multiple statuses, e.g. 'main', 'dns', 'http', etc.
@@ -83,16 +83,16 @@ class HasStatuses(Manageable):
         else:
             self.status[key] = value
 
-    async def diagnose(self, no_deduce: bool = False) -> dict[str, Status]:
+    async def diagnose(self, no_deduce: bool = False) -> dict[str, StatusReport]:
         """Diagnoses the object
 
         Diagnose by calling check methods and setting statuses.
         Methods are called in order, values of later methods may be deduced from earlier ones:
-        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
-        is the same.
+        if some method returns a StatusReport with deduce_other=True, we deduce that the result
+        of all later methods is the same.
         E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
 
-        One can force all diagnotics to be run by setting no_deduce=True.
+        One can force all diagnostics to be run by setting no_deduce=True.
 
         Args:
             no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
@@ -109,11 +109,11 @@ class HasStatuses(Manageable):
             res = await asyncio.gather(*checking_tasks)
         else:
             res = []
-            deduced_status: Status | None = None
+            deduced_status: StatusReport | None = None
             deduced_name: str | None = None
             for n, m in self.check_methods.items():
                 if deduced_status is not None:
-                    r = Status.deduced(deduced_status, f'Deduced from {deduced_name}')
+                    r = StatusReport.deduced(deduced_status, f'Deduced from {deduced_name}')
                 else:
                     r = await calc_state(m)
                     if r.deduce_other:
@@ -122,16 +122,16 @@ class HasStatuses(Manageable):
                 res.append(r)
         return {n: r for n, r in zip(self.check_methods.keys(), res)}
 
-    def diagnose_sync(self, no_deduce: bool = False) -> dict[str, Status]:
+    def diagnose_sync(self, no_deduce: bool = False) -> dict[str, StatusReport]:
         """Diagnoses the object skipping async methods
 
         Diagnose by calling check methods and setting statuses.
         Methods are called in order, values of later methods may be deduced from earlier ones:
-        if some method returns StatusEnum.ok, or StatusEnum.na, we deduce that the result of all later methods
-        is the same.
+        if some method returns a StatusReport with deduce_other=True, we deduce that the result
+        of all later methods is the same.
         E.g. if 'ping' is OK, we deduce that 'dns' is OK too.
 
-        One can force all diagnotics to be run by setting no_deduce=True.
+        One can force all diagnostics to be run by setting no_deduce=True.
 
         Args:
             no_deduce (bool, optional): If True, don't deduce statuses from other statuses. Defaults to False.
@@ -139,7 +139,7 @@ class HasStatuses(Manageable):
 
         def calc_state(m):
             if asyncio.iscoroutinefunction(m):
-                return Status.new_na(msg='Skipped async test')
+                return StatusReport.unknown(msg='Skipped async test')
             else:
                 return m()
 
@@ -147,11 +147,11 @@ class HasStatuses(Manageable):
             res = [calc_state(m) for m in self.check_methods.values()]
         else:
             res = []
-            deduced_status: Status | None = None
+            deduced_status: StatusReport | None = None
             deduced_name: str | None = None
             for n, m in self.check_methods.items():
                 if deduced_status is not None:
-                    r = Status.deduced(deduced_status, f'Deduced from {deduced_name}')
+                    r = StatusReport.deduced(deduced_status, f'Deduced from {deduced_name}')
                 else:
                     r = calc_state(m)
                     if r.deduce_other:
@@ -184,15 +184,17 @@ class HasStatuses(Manageable):
         for n, s in statuses.items():
             self.set_status(n, s)
 
-    def point_of_failure(self) -> (str | None, Status | None):
+    def point_of_failure(self) -> tuple[str | None, StatusReport | None]:
         """Returns the most low-level failed status - most probably the point of failure
 
+        Checks for ERROR and FAILED statuses only (not DEGRADED/WARNING).
+
         Returns:
-            (str, Status): Name and status of the most low-level failed status
+            tuple: (name, StatusReport) of the most low-level failed status, or (None, None)
         """
 
         for k, s in reversed(self.status.items()):
-            if s == StatusEnum.fail:
+            if s.status == Status.ERROR or s.status == Status.FAILED:
                 return k, s
         return None, None
 
@@ -201,7 +203,7 @@ class HasStatuses(Manageable):
         if s is None:
             return 'OK'
         else:
-            return f'Failed {n} ({s.msg})'
+            return f'Failed {n} ({s.message})'
 
     def status_ok(self) -> bool:
         """Returns True if no failed statuses"""

serverish-2.0.0/serverish/base/status.py

@@ -0,0 +1,225 @@
+"""Unified status types for serverish.
+
+Provides a single Status enum and StatusReport dataclass used by every layer
+of the library: diagnostics (HasStatuses), connections, monitoring, and tasks.
+
+Status severity precedence (highest wins in aggregation):
+    FAILED > ERROR > WARNING > DEGRADED > STARTUP > SHUTDOWN > BUSY > IDLE > OK > UNKNOWN
+
+This module replaces the former dual-system design where serverish.base had a
+4-value StatusEnum and serverish.monitoring had a separate 10-value Status enum.
+The two are now unified here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from serverish.base.datetime import dt_from_array, dt_utcnow_array
+
+
+class Status(Enum):
+    """Component/service status.
+
+    Ordered by severity (highest wins in aggregation):
+    FAILED > ERROR > WARNING > DEGRADED > STARTUP > SHUTDOWN > BUSY > IDLE > OK > UNKNOWN
+
+    Properties:
+        is_healthy: True for OK, IDLE, BUSY, DEGRADED, WARNING
+        is_operational: True for STARTUP, OK, IDLE, BUSY, DEGRADED, WARNING
+    """
+    UNKNOWN = "unknown"
+    STARTUP = "startup"
+    OK = "ok"
+    IDLE = "idle"
+    BUSY = "busy"
+    DEGRADED = "degraded"
+    WARNING = "warning"
+    ERROR = "error"
+    SHUTDOWN = "shutdown"
+    FAILED = "failed"
+
+    def __str__(self) -> str:
+        return self.value
+
+    @property
+    def is_healthy(self) -> bool:
+        """True for OK, IDLE, BUSY, DEGRADED, WARNING."""
+        return self in _HEALTHY_STATUSES
+
+    @property
+    def is_operational(self) -> bool:
+        """True for STARTUP, OK, IDLE, BUSY, DEGRADED, WARNING."""
+        return self in _OPERATIONAL_STATUSES
+
+
+_HEALTHY_STATUSES = frozenset({
+    Status.OK, Status.IDLE, Status.BUSY, Status.DEGRADED, Status.WARNING,
+})
+
+_OPERATIONAL_STATUSES = frozenset({
+    Status.STARTUP, Status.OK, Status.IDLE, Status.BUSY,
+    Status.DEGRADED, Status.WARNING,
+})
+
+_SEVERITY_RANK: dict[Status, int] = {
+    Status.UNKNOWN: 0,
+    Status.OK: 1,
+    Status.IDLE: 2,
+    Status.BUSY: 3,
+    Status.SHUTDOWN: 4,
+    Status.STARTUP: 5,
+    Status.DEGRADED: 6,
+    Status.WARNING: 7,
+    Status.ERROR: 8,
+    Status.FAILED: 9,
+}
+
+
+@dataclass
+class StatusReport:
+    """Status report for any component.
+
+    Used both as a diagnostic check result (with deduce_other for deduction
+    chains in HasStatuses) and as a rich status report (with details, children,
+    and metrics for monitoring).
+
+    Args:
+        name: Component name
+        status: Current status
+        message: Optional human-readable message
+        timestamp: UTC timestamp as 7-element array [Y, M, D, h, m, s, us]
+        details: Optional dict with children reports and metrics
+        parent: Optional parent name for hierarchical grouping
+        deduce_other: If True, subsequent diagnostic checks are deduced from this result
+    """
+    name: str
+    status: Status
+    message: str | None = None
+    timestamp: list[int] | None = None
+    details: dict[str, Any] | None = None
+    parent: str | None = None
+    deduce_other: bool = False
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = dt_utcnow_array()
+
+    def get_timestamp_dt(self):
+        """Get timestamp as datetime object."""
+        if self.timestamp is None:
+            return None
+        return dt_from_array(self.timestamp)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        result: dict[str, Any] = {
+            "name": self.name,
+            "status": self.status.value,
+            "timestamp": self.timestamp,
+        }
+        if self.message:
+            result["message"] = self.message
+        if self.details:
+            result["details"] = self.details
+        if self.parent:
+            result["parent"] = self.parent
+        if self.deduce_other:
+            result["deduce_other"] = True
+        return result
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> StatusReport:
+        """Create from dictionary.
+
+        Raises:
+            KeyError: If required fields 'name' or 'status' are missing
+            ValueError: If 'status' value is not a valid Status enum member
+        """
+        if "name" not in data or "status" not in data:
+            missing = [k for k in ("name", "status") if k not in data]
+            raise KeyError(f"StatusReport.from_dict missing required fields: {missing}")
+        return cls(
+            name=data["name"],
+            status=Status(data["status"]),
+            message=data.get("message"),
+            timestamp=data.get("timestamp"),
+            details=data.get("details"),
+            parent=data.get("parent"),
+            deduce_other=data.get("deduce_other", False),
+        )
+
+    @staticmethod
+    def ok(msg: str | None = None, deduce_other: bool = True) -> StatusReport:
+        """Create an OK status report. Defaults deduce_other=True."""
+        return StatusReport(name="", status=Status.OK, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def error(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create an ERROR status report."""
+        return StatusReport(name="", status=Status.ERROR, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def failed(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create a FAILED status report."""
+        return StatusReport(name="", status=Status.FAILED, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def unknown(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create an UNKNOWN status report."""
+        return StatusReport(name="", status=Status.UNKNOWN, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def shutdown(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create a SHUTDOWN status report."""
+        return StatusReport(name="", status=Status.SHUTDOWN, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def degraded(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create a DEGRADED status report."""
+        return StatusReport(name="", status=Status.DEGRADED, message=msg, deduce_other=deduce_other)
+
+    @staticmethod
+    def warning(msg: str | None = None, deduce_other: bool = False) -> StatusReport:
+        """Create a WARNING status report."""
+        return StatusReport(name="", status=Status.WARNING, message=msg, deduce_other=deduce_other)
+
+    @classmethod
+    def deduced(cls, source: StatusReport, msg: str | None = None) -> StatusReport:
+        """Create a status report deduced from another result.
+
+        Used by HasStatuses diagnostic chains when a prior check's
+        deduce_other=True allows skipping subsequent checks.
+
+        Args:
+            source: The StatusReport to deduce from
+            msg: Optional message (defaults to 'Deduced')
+        """
+        if msg is None:
+            msg = "Deduced"
+        return cls(
+            name="",
+            status=source.status,
+            message=msg,
+            deduce_other=False,
+        )
+
+
+def aggregate_status(reports: list[StatusReport]) -> Status:
+    """Aggregate multiple status reports into single status.
+
+    Returns the most severe status from the collection, following
+    severity precedence:
+    FAILED > ERROR > WARNING > DEGRADED > STARTUP > SHUTDOWN > BUSY > IDLE > OK > UNKNOWN
+
+    Args:
+        reports: List of StatusReport instances
+
+    Returns:
+        The most severe Status from the reports, or Status.UNKNOWN if empty
+    """
+    if not reports:
+        return Status.UNKNOWN
+    return max((r.status for r in reports), key=lambda s: _SEVERITY_RANK[s])

{serverish-1.5.0 → serverish-2.0.0}/serverish/base/task_manager.py

@@ -3,7 +3,7 @@ import logging
 
 import param
 
-from serverish.base import Status
+from serverish.base import StatusReport
 from serverish.base.asyncio_util_functions import wait_for_psce
 from serverish.base.collector import Collector
 from serverish.base.hasstatuses import HasStatuses
@@ -42,14 +42,14 @@ class Task(HasStatuses):
                 e = task.exception()
             except asyncio.CancelledError:
                 logger.debug(f'Task {self.name} canceled')
-                self.set_status('running', Status.new_na(msg='Task canceled'))
+                self.set_status('running', StatusReport.unknown(msg='Task canceled'))
             else:
                 if e is not None:
                     logger.error(f'Task {self.name} failed: {task.exception()}', exc_info=task.exception())
-                    self.set_status('running', Status.new_fail(msg=f'Task failed: {task.exception()}'))
+                    self.set_status('running', StatusReport.error(msg=f'Task failed: {task.exception()}'))
                 else:
                     logger.debug(f'Task {self.name} done')
-                    self.set_status('running', Status.new_na(msg='Task finished'))
+                    self.set_status('running', StatusReport.unknown(msg='Task finished'))
             self.remove_parent()
 
         self.task = asyncio.create_task(self.coro, name=self.name)

{serverish-1.5.0 → serverish-2.0.0}/serverish/connection/connection.py

@@ -7,7 +7,7 @@ from typing import Iterable
 
 import param
 from serverish.base.hasstatuses import HasStatuses
-from serverish.base.status import Status
+from serverish.base.status import StatusReport
 
 logger = logging.getLogger(__name__.rsplit('.')[-1])
 
@@ -70,7 +70,7 @@ class Connection(HasStatuses):
                 return f'{h}: {e}'
 
 
-    async def diagnose_dns(self) -> Status:
+    async def diagnose_dns(self) -> StatusReport:
         """ Diagnoses DNS connection
 
         Returns:
@@ -79,11 +79,11 @@ class Connection(HasStatuses):
         try:
             import aiodns
         except ImportError:
-            return Status.new_na(msg='aiodns not installed, skipping DNS check')
+            return StatusReport.unknown(msg='aiodns not installed, skipping DNS check')
 
 
         if len(self.host) == 0:
-            return Status.new_na(msg='No hosts to check DNS for')
+            return StatusReport.unknown(msg='No hosts to check DNS for')
 
         resolver = aiodns.DNSResolver()
         tasks = [self._check_host(resolver, h) for h in self.host if not self.is_ip(h)]
@@ -93,16 +93,16 @@ class Connection(HasStatuses):
         failed = [res for res in results if res is not None]
 
         if checked == 0:
-            return Status.new_na(msg='No DNS names to check')
+            return StatusReport.unknown(msg='No DNS names to check')
         elif len(failed) == checked:
-            return Status.new_fail(msg=f'DNS check failed for all {checked} names: {", ".join(failed)}')
+            return StatusReport.error(msg=f'DNS check failed for all {checked} names: {", ".join(failed)}')
         elif len(failed) > 0:
-            return Status.new_ok(msg=f'DNS check ok for {checked - len(failed)} of {checked} names, '
+            return StatusReport.ok(msg=f'DNS check ok for {checked - len(failed)} of {checked} names, '
                                      f'but failed for: {", ".join(failed)}')
         else:
-            return Status.new_ok(msg=f'DNS check ok for all {checked} names')
+            return StatusReport.ok(msg=f'DNS check ok for all {checked} names')
 
-    async def diagnose_ping(self) -> Status:
+    async def diagnose_ping(self) -> StatusReport:
         """Diagnoses ping
 
         Returns:
@@ -118,7 +118,7 @@ class Connection(HasStatuses):
             return (host, proc.returncode)
 
         if len(self.host) == 0:
-            return Status.new_na(msg='No hosts to ping')
+            return StatusReport.unknown(msg='No hosts to ping')
 
         tasks = [_ping_host(host) for host in self.host]
         results = await asyncio.gather(*tasks)
@@ -127,12 +127,12 @@ class Connection(HasStatuses):
         failed_pings = [host for host, returncode in results if returncode != 0]
 
         if len(successful_pings) == len(self.host):
-            return Status.new_ok(msg=f'Ping successful for all hosts: {", ".join(successful_pings)}')
+            return StatusReport.ok(msg=f'Ping successful for all hosts: {", ".join(successful_pings)}')
         elif len(successful_pings) > 0:
-            return Status.new_ok(msg=f'Ping ok for {len(successful_pings)} of {len(self.host)} hosts, '
+            return StatusReport.ok(msg=f'Ping ok for {len(successful_pings)} of {len(self.host)} hosts, '
                                      f'but failed for: {", ".join(failed_pings)}')
         else:
-            return Status.new_fail(msg=f'Ping failed for all {len(self.host)} hosts: {", ".join(failed_pings)}')
+            return StatusReport.error(msg=f'Ping failed for all {len(self.host)} hosts: {", ".join(failed_pings)}')
 
     def create_urls(self, protocol: str='http', path: str='') -> list[str]:
         """Creates list of URLs from host and port

{serverish-1.5.0 → serverish-2.0.0}/serverish/connection/connection_jets.py

@@ -9,7 +9,7 @@ from nats.js import JetStreamContext
 import param
 
 from serverish.connection.connection_nats import ConnectionNATS
-from serverish.base.status import Status
+from serverish.base.status import StatusReport
 
 logger = logging.getLogger(__name__.rsplit('.')[-1])
 
@@ -148,7 +148,7 @@ class ConnectionJetStream(ConnectionNATS):
         await js.update_stream(config=cfg)
 
 
-    async def diagnose_stream_config(self) -> Status:
+    async def diagnose_stream_config(self) -> StatusReport:
         """Diagnoses stream configuration
 
         Returns:
@@ -160,12 +160,12 @@ class ConnectionJetStream(ConnectionNATS):
         try:
             for s in self.streams:
                 if re.match(r'^[a-zA-Z0-9_-]+$', s) is None:
-                    return Status.new_fail(msg=f'Invalid stream name {s}')
+                    return StatusReport.error(msg=f'Invalid stream name {s}')
         except TypeError:
-            return Status.new_fail(msg='Streams config invalid, can not iterate over it')
-        return Status.new_ok(msg='Streams config valid', deduce_other=False)
+            return StatusReport.error(msg='Streams config invalid, can not iterate over it')
+        return StatusReport.ok(msg='Streams config valid', deduce_other=False)
 
-    async def diagnose_jetstream_init(self) -> Status:
+    async def diagnose_jetstream_init(self) -> StatusReport:
         """Diagnoses JetStream connection
 
         Returns:
@@ -173,11 +173,11 @@ class ConnectionJetStream(ConnectionNATS):
         """
         js: JetStreamContext = self.js
         if js is None:
-            return Status.new_fail(msg='Not initialized')
+            return StatusReport.error(msg='Not initialized')
         else:
-            return Status.new_ok(msg='Initialized', deduce_other=False)
+            return StatusReport.ok(msg='Initialized', deduce_other=False)
 
-    async def diagnose_stream_exists(self) -> Status:
+    async def diagnose_stream_exists(self) -> StatusReport:
         """Diagnoses any stream existence
 
         Returns:
@@ -185,16 +185,16 @@ class ConnectionJetStream(ConnectionNATS):
         """
         js: JetStreamContext = self.js
         if js is None:
-            return Status.new_fail(msg='Not initialized')
+            return StatusReport.error(msg='Not initialized')
         try:
             info = await js.streams_info()
             if not info:
-                return Status.new_fail(msg='Zero streams in NATS')
+                return StatusReport.error(msg='Zero streams in NATS')
         except Exception as e:
-            return Status.new_fail(msg=f'Error getting streams info: {e}')
-        return Status.new_ok(msg='Stream(s) exist')
+            return StatusReport.error(msg=f'Error getting streams info: {e}')
+        return StatusReport.ok(msg='Stream(s) exist')
 
-    async def diagnose_stream_subjects(self) -> Status:
+    async def diagnose_stream_subjects(self) -> StatusReport:
         """Diagnoses streams for declared subjects
 
         Returns:
@@ -202,15 +202,15 @@ class ConnectionJetStream(ConnectionNATS):
         """
         js: JetStreamContext = self.js
         if js is None:
-            return Status.new_fail(msg='Not initialized')
+            return StatusReport.error(msg='Not initialized')
         if not self.declared_subjects:
-            return Status.new_na(msg='No declared subjects')
+            return StatusReport.unknown(msg='No declared subjects')
         try:
             for subject in self.declared_subjects:
                 try:
                     await js.find_stream_name_by_subject(subject)
                 except (LookupError, TypeError) as e:  # That's what nats.py throws...
-                    return Status.new_fail(msg=f'Stream for {subject} not found')
+                    return StatusReport.error(msg=f'Stream for {subject} not found')
         except Exception as e:
-            return Status.new_fail(msg=f'Error getting streams info: {e}')
-        return Status.new_ok(msg='All declared subjects have streams')
+            return StatusReport.error(msg=f'Error getting streams info: {e}')
+        return StatusReport.ok(msg='All declared subjects have streams')