aspyx-service 0.10.1__tar.gz → 0.10.3__tar.gz

{aspyx_service-0.10.1 → aspyx_service-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aspyx_service
-Version: 0.10.1
+Version: 0.10.3
 Summary: Aspyx Service framework
 Author-email: Andreas Ernst <andreas.ernst7@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.9
-Requires-Dist: aspyx>=1.5.0
+Requires-Dist: aspyx>=1.5.1
 Requires-Dist: fastapi~=0.115.13
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: msgpack~=1.1.1
@@ -34,6 +34,18 @@ Requires-Dist: python-consul2~=0.1.5
 Requires-Dist: uvicorn[standard]
 Description-Content-Type: text/markdown
 
+# aspyx
+
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
+![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/aspyx)](https://pypi.org/project/aspyx/)
+[![Docs](https://img.shields.io/badge/docs-online-blue?logo=github)](https://coolsamson7.github.io/aspyx/index/introduction)
+
+![image](https://github.com/user-attachments/assets/e808210a-b1a4-4fd0-93f1-b5f9845fa520)
+
 # Service
 
 - [Introduction](#introduction)
@@ -58,19 +70,23 @@ that lets you deploy, discover and call services with different remoting protoco
 
 The basic design consists of four different concepts:
 
-!!! info "Service"
+**Service**
+
   defines a group of methods that can be called either locally or remotely. 
   These methods represent the functional interface exposed to clients — similar to an interface in traditional programming
 
-!!! info "Component"
+**Component**
+
   a component bundles one or more services and declares the channels (protocols) used to expose them.
   Think of a component as a deployment unit or module.
 
-!!! info "Component Registry "
+**Component Registry**
+
   acts as the central directory for managing available components.
   It allows the framework to register, discover, and resolve components and their services.
 
-!!! info "Channel"
+**Channel**
+
   is a pluggable transport layer that defines how service method invocations are transmitted and handled.
 
 Let's look at the "interface" layer first.
@@ -99,7 +115,7 @@ class Module:
     
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, "http://localhost:8500") # a consul based registry!
+        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=8500)) # a consul based registry!
 
 environment = Environment(Module)
 service_manager = environment.get(ServiceManager)
@@ -349,7 +365,7 @@ A so called `URLSelector` is used internally to provide URLs for every single ca
 - `FirstURLSelector` always returns the first URL of the list of possible URLs
 - `RoundRobinURLSelector` switches sequentially between all URLs.
 
-To customize the behavior, an around advice can be implemented easily:
+To customize the behavior, an `around` advice can be implemented easily:
 
 **Example**:
  

{aspyx_service-0.10.1 → aspyx_service-0.10.3}/README.md

@@ -1,3 +1,15 @@
+# aspyx
+
+![Pylint](https://github.com/coolsamson7/aspyx/actions/workflows/pylint.yml/badge.svg)
+![Build Status](https://github.com/coolsamson7/aspyx/actions/workflows/ci.yml/badge.svg)
+![Python Versions](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12-blue)
+![License](https://img.shields.io/github/license/coolsamson7/aspyx)
+![coverage](https://img.shields.io/badge/coverage-94%25-brightgreen)
+[![PyPI](https://img.shields.io/pypi/v/aspyx)](https://pypi.org/project/aspyx/)
+[![Docs](https://img.shields.io/badge/docs-online-blue?logo=github)](https://coolsamson7.github.io/aspyx/index/introduction)
+
+![image](https://github.com/user-attachments/assets/e808210a-b1a4-4fd0-93f1-b5f9845fa520)
+
 # Service
 
 - [Introduction](#introduction)
@@ -22,19 +34,23 @@ that lets you deploy, discover and call services with different remoting protoco
 
 The basic design consists of four different concepts:
 
-!!! info "Service"
+**Service**
+
   defines a group of methods that can be called either locally or remotely. 
   These methods represent the functional interface exposed to clients — similar to an interface in traditional programming
 
-!!! info "Component"
+**Component**
+
   a component bundles one or more services and declares the channels (protocols) used to expose them.
   Think of a component as a deployment unit or module.
 
-!!! info "Component Registry "
+**Component Registry**
+
   acts as the central directory for managing available components.
   It allows the framework to register, discover, and resolve components and their services.
 
-!!! info "Channel"
+**Channel**
+
   is a pluggable transport layer that defines how service method invocations are transmitted and handled.
 
 Let's look at the "interface" layer first.
@@ -63,7 +79,7 @@ class Module:
     
     @create()
     def create_registry(self) -> ConsulComponentRegistry:
-        return ConsulComponentRegistry(Server.port, "http://localhost:8500") # a consul based registry!
+        return ConsulComponentRegistry(Server.port, Consul(host="localhost", port=8500)) # a consul based registry!
 
 environment = Environment(Module)
 service_manager = environment.get(ServiceManager)
@@ -313,7 +329,7 @@ A so called `URLSelector` is used internally to provide URLs for every single ca
 - `FirstURLSelector` always returns the first URL of the list of possible URLs
 - `RoundRobinURLSelector` switches sequentially between all URLs.
 
-To customize the behavior, an around advice can be implemented easily:
+To customize the behavior, an `around` advice can be implemented easily:
 
 **Example**:
  

aspyx_service-0.10.3/performance_tests/performance-test.py

@@ -0,0 +1,205 @@
+"""
+Tests
+"""
+import asyncio
+import logging
+import threading
+import time
+
+from typing import Callable, TypeVar, Type, Awaitable, Any
+
+from packages.aspyx_service.tests.common import service_manager, TestService, TestRestService, Pydantic, Data, \
+    TestAsyncRestService, TestAsyncService
+from packages.aspyx_service.tests.test_async_service import data
+
+T = TypeVar("T")
+
+# main
+
+pydantic = Pydantic(i=1, f=1.0, b=True, s="s")
+data = Data(i=1, f=1.0, b=True, s="s")
+
+def run_loops(name: str, loops: int, type: Type[T], instance: T,  callable: Callable[[T], None]):
+    start = time.perf_counter()
+    for _ in range(loops):
+        callable(instance)
+
+    end = time.perf_counter()
+    avg_ms = ((end - start) / loops) * 1000
+
+    print(f"run {name}, loops={loops}: avg={avg_ms:.3f} ms")
+
+async def run_async_loops(name: str, loops: int, type: Type[T], instance: T,  callable: Callable[[T], Awaitable[Any]]):
+    start = time.perf_counter()
+    for _ in range(loops):
+        await callable(instance)
+
+    end = time.perf_counter()
+    avg_ms = ((end - start) / loops) * 1000
+
+    print(f"run {name}, loops={loops}: avg={avg_ms:.3f} ms")
+
+def run_threaded_async_loops(name: str, loops: int, n_threads: int,  type: Type[T], instance: T,  callable: Callable[[T], Awaitable[Any]]):
+    threads = []
+
+    def worker(thread_id: int):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        async def run():
+            for i in range(loops):
+                await callable(instance)
+
+        loop.run_until_complete(run())
+        loop.close()
+
+    start = time.perf_counter()
+
+    for t_id in range(0, n_threads):
+        thread = threading.Thread(target=worker, args=(t_id,))
+        threads.append(thread)
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+    end = time.perf_counter()
+    took = (end - start) * 1000
+    avg_ms = ((end - start) / (n_threads * loops)) * 1000
+
+    print(f"{name} {loops} in {n_threads} threads: {took} ms, avg: {avg_ms}ms")
+
+def run_threaded_sync_loops(name: str, loops: int, n_threads: int,  type: Type[T], instance: T,  callable: Callable[[T], Any]):
+    threads = []
+
+    def worker(thread_id: int):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        async def run():
+            for i in range(loops):
+                callable(instance)
+
+        loop.run_until_complete(run())
+        loop.close()
+
+    start = time.perf_counter()
+
+    for t_id in range(0, n_threads):
+        thread = threading.Thread(target=worker, args=(t_id,))
+        threads.append(thread)
+        thread.start()
+
+    for thread in threads:
+        thread.join()
+
+    end = time.perf_counter()
+    took = (end - start) * 1000
+    avg_ms = ((end - start) / (n_threads * loops)) * 1000
+
+    print(f"{name} {loops} in {n_threads} threads: {took} ms, avg: {avg_ms}ms")
+
+async def main():
+    # get service manager
+
+    manager = service_manager()
+    loops = 1000
+
+    # tests
+
+    run_loops("rest", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"), lambda service: service.get("world"))
+    run_loops("json", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-json"), lambda service: service.hello("world"))
+    run_loops("msgpack", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-msgpack"), lambda service: service.hello("world"))
+
+    # pydantic
+
+    run_loops("rest & pydantic", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"), lambda service: service.post_pydantic("hello", pydantic))
+    run_loops("json & pydantic", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-json"), lambda service: service.pydantic(pydantic))
+    run_loops("msgpack & pydantic", loops, TestService, manager.get_service(TestService, preferred_channel="dispatch-msgpack"), lambda service: service.pydantic(pydantic))
+
+    # data class
+
+    run_loops("rest & data", loops, TestRestService, manager.get_service(TestRestService, preferred_channel="rest"),
+              lambda service: service.post_data("hello", data))
+    run_loops("json & data", loops, TestService,
+              manager.get_service(TestService, preferred_channel="dispatch-json"),
+              lambda service: service.data(data))
+    run_loops("msgpack & data", loops, TestService,
+              manager.get_service(TestService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.data(data))
+
+    # async
+
+    await run_async_loops("async rest", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.get("world"))
+    await run_async_loops("async json", loops, TestAsyncService, manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.hello("world"))
+    await run_async_loops("async msgpack", loops, TestAsyncService, manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.hello("world"))
+
+    # pydantic
+
+    await run_async_loops("async rest & pydantic", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.post_pydantic("hello", pydantic))
+    await run_async_loops("async json & pydantic", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.pydantic(pydantic))
+    await run_async_loops("async msgpack & pydantic", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.pydantic(pydantic))
+
+    # data class
+
+    # pydantic
+
+    await run_async_loops("async rest & data", loops, TestAsyncRestService, manager.get_service(TestAsyncRestService, preferred_channel="rest"),
+              lambda service: service.post_data("hello", data))
+    await run_async_loops("async json & data", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+              lambda service: service.data(data))
+    await run_async_loops("async msgpack & data", loops, TestAsyncService,
+              manager.get_service(TestAsyncService, preferred_channel="dispatch-msgpack"),
+              lambda service: service.data(data))
+
+    # a real thread test
+
+    # sync
+
+    run_threaded_sync_loops("threaded sync json, 1 thread", loops, 1, TestService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 2 thread", loops, 2, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 4 thread", loops, 4, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 8 thread", loops, 8, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_sync_loops("threaded sync json, 16 thread", loops, 16, TestService,
+                             manager.get_service(TestService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+
+    # async
+
+    run_threaded_async_loops("threaded async json, 1 thread", loops, 1, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world") )
+    run_threaded_async_loops("threaded async json, 2 thread", loops, 2, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 4 thread", loops, 4, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 8 thread", loops, 8, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+    run_threaded_async_loops("threaded async json, 16 thread", loops, 16, TestAsyncService,
+                             manager.get_service(TestAsyncService, preferred_channel="dispatch-json"),
+                             lambda service: service.hello("world"))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

{aspyx_service-0.10.1 → aspyx_service-0.10.3}/pyproject.toml

@@ -2,14 +2,14 @@
 
 [project]
 name = "aspyx_service"
-version = "0.10.1"
+version = "0.10.3"
 description = "Aspyx Service framework"
 authors = [{ name = "Andreas Ernst", email = "andreas.ernst7@gmail.com" }]
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"
 dependencies = [
-    "aspyx>=1.5.0",
+    "aspyx>=1.5.1",
     "python-consul2~=0.1.5",
     "fastapi~=0.115.13",
     "httpx~=0.28.1",

{aspyx_service-0.10.1 → aspyx_service-0.10.3}/src/aspyx_service/channels.py

@@ -11,8 +11,10 @@ import msgpack
 from httpx import Client, AsyncClient
 from pydantic import BaseModel
 
+from aspyx.di.configuration import inject_value
 from aspyx.reflection import DynamicProxy, TypeDescriptor
-from .service import ServiceManager
+from aspyx.threading import ThreadLocal
+from .service import ServiceManager, ServiceCommunicationException
 
 from .service import ComponentDescriptor, ChannelInstances, ServiceException, channel, Channel, RemoteServiceException
 from .serialization import get_deserializer
@@ -23,9 +25,15 @@ class HTTPXChannel(Channel):
         "client",
         "async_client",
         "service_names",
-        "deserializers"
+        "deserializers",
+        "timeout"
     ]
 
+    # class properties
+
+    client_local = ThreadLocal[Client]()
+    async_client_local = ThreadLocal[AsyncClient]()
+
     # class methods
 
     @classmethod
@@ -58,11 +66,16 @@ class HTTPXChannel(Channel):
     def __init__(self):
         super().__init__()
 
-        self.client: Optional[Client] = None
-        self.async_client: Optional[AsyncClient] = None
+        self.timeout = 1000.0
         self.service_names: dict[Type, str] = {}
         self.deserializers: dict[Callable, Callable] = {}
 
+    # inject
+
+    @inject_value("http.timeout", default=1000.0)
+    def set_timeout(self, timeout: float) -> None:
+        self.timeout = timeout
+
     # protected
 
     def get_deserializer(self, type: Type, method: Callable) -> Type:
@@ -86,29 +99,30 @@ class HTTPXChannel(Channel):
         for service in component_descriptor.services:
             self.service_names[service.type] = service.name
 
-        # make client
-
-        self.client = self.make_client()
-        self.async_client = self.make_async_client()
-
     # public
 
     def get_client(self) -> Client:
-        if self.client is None:
-            self.client = self.make_client()
+        client = self.client_local.get()
+
+        if client is None:
+            client = self.make_client()
+            self.client_local.set(client)
 
-        return self.client
+        return client
 
-    def get_async_client(self) -> Client:
-        if self.async_client is None:
-            self.async_client = self.make_async_client()
+    def get_async_client(self) -> AsyncClient:
+        async_client = self.async_client_local.get()
 
-        return self.async_client
+        if async_client is None:
+            async_client = self.make_async_client()
+            self.async_client_local.set(async_client)
 
-    def make_client(self):
+        return async_client
+
+    def make_client(self) -> Client:
         return Client()  # base_url=url
 
-    def make_async_client(self):
+    def make_async_client(self) -> AsyncClient:
         return AsyncClient()  # base_url=url
 
 class Request(BaseModel):
@@ -122,7 +136,7 @@ class Response(BaseModel):
 @channel("dispatch-json")
 class DispatchJSONChannel(HTTPXChannel):
     """
-    A channel that calls a POST on th endpoint `ìnvoke` sending a request body containing information on the
+    A channel that calls a POST on the endpoint `ìnvoke` sending a request body containing information on the
     called component, service and method and the arguments.
     """
     # constructor
@@ -144,40 +158,49 @@ class DispatchJSONChannel(HTTPXChannel):
 
     def invoke(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
-        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}", args=invocation.args)
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+                          args=invocation.args)
 
         dict = self.to_dict(request)
         try:
-            if self.client is not None:
-                result = Response(**self.get_client().post(f"{self.get_url()}/invoke", json=dict, timeout=30000.0).json())
-                if result.exception is not None:
-                    raise RemoteServiceException(f"server side exception {result.exception}")
-
-                return self.get_deserializer(invocation.type, invocation.method)(result.result)
-            else:
-                raise ServiceException(f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+            result = Response(**self.get_client().post(f"{self.get_url()}/invoke", json=dict, timeout=self.timeout).json())
+            if result.exception is not None:
+                raise RemoteServiceException(f"server side exception {result.exception}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.result)
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
-            raise ServiceException(f"communication exception {e}") from e
+            raise ServiceCommunicationException(f"communication exception {e}") from e
+
 
     async def invoke_async(self, invocation: DynamicProxy.Invocation):
         service_name = self.service_names[invocation.type]  # map type to registered service name
         request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
                           args=invocation.args)
-
         dict = self.to_dict(request)
         try:
-            if self.async_client is not None:
-                data =  await self.async_client.post(f"{self.get_url()}/invoke", json=dict, timeout=30000.0)
-                result = Response(**data.json())
-                if result.exception is not None:
-                    raise RemoteServiceException(f"server side exception {result.exception}")
-
-                return self.get_deserializer(invocation.type, invocation.method)(result.result)
-            else:
-                raise ServiceException(
-                    f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+            data =  await self.get_async_client().post(f"{self.get_url()}/invoke", json=dict, timeout=self.timeout)
+            result = Response(**data.json())
+
+            if result.exception is not None:
+                raise RemoteServiceException(f"server side exception {result.exception}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result.result)
+
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
-            raise ServiceException(f"communication exception {e}") from e
+            raise ServiceCommunicationException(f"communication exception {e}") from e
+
 
 @channel("dispatch-msgpack")
 class DispatchMSPackChannel(HTTPXChannel):
@@ -208,7 +231,7 @@ class DispatchMSPackChannel(HTTPXChannel):
                 f"{self.get_url()}/invoke",
                 content=packed,
                 headers={"Content-Type": "application/msgpack"},
-                timeout=30.0
+                timeout=self.timeout
             )
 
             result = msgpack.unpackb(response.content, raw=False)
@@ -218,6 +241,12 @@ class DispatchMSPackChannel(HTTPXChannel):
 
             return self.get_deserializer(invocation.type, invocation.method)(result["result"])
 
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
             raise ServiceException(f"msgpack exception: {e}") from e
 
@@ -233,7 +262,7 @@ class DispatchMSPackChannel(HTTPXChannel):
                 f"{self.get_url()}/invoke",
                 content=packed,
                 headers={"Content-Type": "application/msgpack"},
-                timeout=30.0
+                timeout=self.timeout
             )
 
             result = msgpack.unpackb(response.content, raw=False)
@@ -243,5 +272,11 @@ class DispatchMSPackChannel(HTTPXChannel):
 
             return self.get_deserializer(invocation.type, invocation.method)(result["result"])
 
+        except ServiceCommunicationException:
+            raise
+
+        except RemoteServiceException:
+            raise
+
         except Exception as e:
             raise ServiceException(f"msgpack exception: {e}") from e

{aspyx_service-0.10.1 → aspyx_service-0.10.3}/src/aspyx_service/registries.py

@@ -6,7 +6,6 @@ import threading
 from abc import abstractmethod
 import time
 from typing import Optional
-from urllib.parse import urlparse
 
 import consul
 
@@ -36,6 +35,9 @@ class ConsulComponentRegistry(ComponentRegistry):
         self.component_addresses : dict[str, dict[str, ChannelInstances]] = {} # comp -> channel -> address
         self.watch_channels : list[Channel] = []
         self.watchdog_interval = 5
+        self.healthcheck_interval = "10s"
+        self.healthcheck_timeout= "5s"
+        self.healthcheck_deregister = "5m"
 
     # injections
 
@@ -43,6 +45,18 @@ class ConsulComponentRegistry(ComponentRegistry):
     def set_interval(self, interval):
         self.watchdog_interval = interval
 
+    @inject_value("consul.healthcheck.interval", default="10s")
+    def set_interval(self, interval):
+        self.healthcheck_interval = interval
+
+    @inject_value("consul.healthcheck.timeout", default="3s")
+    def set_interval(self, interval):
+        self.healthcheck_timeout = interval
+
+    @inject_value("consul.healthcheck.deregister", default="5m")
+    def set_interval(self, interval):
+        self.healthcheck_deregister = interval
+
     # lifecycle hooks
 
     @on_init()
@@ -116,8 +130,6 @@ class ConsulComponentRegistry(ComponentRegistry):
     def watch(self, channel: Channel) -> None:
         self.watch_channels.append(channel)
 
-        #self.component_addresses[channel.component_descriptor.name] = {}
-
    # public
 
     def register_service(self, name, service_id, health: str, tags=None, meta=None) -> None:
@@ -130,9 +142,9 @@ class ConsulComponentRegistry(ComponentRegistry):
             meta=meta or {},
             check=consul.Check().http(
                 url=f"http://{self.ip}:{self.port}{health}",
-                interval="10s",
-                timeout="3s",
-                deregister="5m")
+                interval=self.healthcheck_interval,
+                timeout=self.healthcheck_timeout,
+                deregister=self.healthcheck_deregister)
             )
 
     def deregister(self, descriptor: ComponentDescriptor[Component]) -> None:
@@ -213,12 +225,13 @@ class ConsulComponentRegistry(ComponentRegistry):
 
         return list(component_addresses.values())
 
-    #200–299	passing	Service is healthy (OK, Created, No Content…)
-    #429	warning	Rate limited or degraded
-    #300–399	warning	Redirects interpreted as potential issues
-    #400–499	critical	Client errors (Bad Request, Unauthorized…)
-    #500–599	critical	Server errors (Internal Error, Timeout…)
-    #Other / No response	critical	Timeout, connection refused, etc.
+    # 200–299	passing	Service is healthy (OK, Created, No Content…)
+    # 429	warning	Rate limited or degraded
+    # 300–399	warning	Redirects interpreted as potential issues
+    # 400–499	critical	Client errors (Bad Request, Unauthorized…)
+    # 500–599	critical	Server errors (Internal Error, Timeout…)
+    # Other / No response	critical	Timeout, connection refused, etc.
+
     def map_health(self, health: HealthCheckManager.Health) -> int:
         if health.status is HealthStatus.OK:
             return 200