refactor: Remove redundant logging statements in RouterClusterMonitor, WebClusterMonitor, PendingAuthCryptosign, and RouterController

Author: Marko Petzold

crossbar/master/cluster/routercluster.py

@@ -522,14 +522,6 @@ def _update_workergroup_transports(self):
                     desired_principals.update(rlink_principals)
                     desired_principals.update(proxy_principals)
 
-                    self.log.info(
-                        '{func} Preparing hot-reload for transport {transport_id}: rlinks={rlink_authids}, proxies={proxy_authids}, total={total_authids}',
-                        func=hltype(self._update_workergroup_transports),
-                        transport_id=hlid(transport_id),
-                        rlink_authids=list(rlink_principals.keys()),
-                        proxy_authids=list(proxy_principals.keys()),
-                        total_authids=list(desired_principals.keys()))
-
                     # Hot-reload principals without restarting transport
                     # This avoids dropping connections and changing the port
                     # With hot-reload, we can just push the desired state directly
@@ -542,24 +534,15 @@ def _update_workergroup_transports(self):
                         continue
 
                     try:
-                        self.log.info(
-                            '{func} Calling update_router_transport_principals for {transport_id} with {count} principals',
-                            func=hltype(self._update_workergroup_transports),
-                            transport_id=hlid(transport_id),
-                            count=len(desired_principals))
-                        
-                        result = yield self._manager._session.call(
+                        yield self._manager._session.call(
                             'crossbarfabriccenter.remote.router.update_router_transport_principals',
                             str(node_oid), worker_name, transport_id, desired_principals)
 
                         self.log.info(
-                            '{func} Successfully hot-updated transport {transport_id} principals on worker {worker_name}: '
-                            'methods={auth_methods}, count={count}',
+                            '{func} Successfully hot-updated transport {transport_id} principals: {principal_authids}',
                             func=hltype(self._update_workergroup_transports),
                             transport_id=hlid(transport_id),
-                            worker_name=hlid(worker_name),
-                            auth_methods=result.get('auth_methods_updated', result.get('authenticators_updated', [])),
-                            count=hlval(result.get('principal_count', 0), color='green'))
+                            principal_authids=list(desired_principals.keys()))
                     except Exception as e:
                         self.log.error(
                             '{func} Failed to hot-update transport {transport_id} principals: {error}',

crossbar/master/cluster/webcluster.py

@@ -204,6 +204,7 @@ def _check_and_apply(self):
                                     worker_options)
                                 worker = yield self._manager._session.call(
                                     'crossbarfabriccenter.remote.node.get_worker', node_oid, worker_id)
+                                
                                 self.log.info(
                                     '{func} Web cluster worker {worker_id} started on node {node_oid} [{worker_started}]',
                                     func=hltype(self._check_and_apply),
@@ -409,8 +410,7 @@ def _check_and_apply(self):
                                             arealm_oid=hlid(arealm_oid),
                                             workergroup_oid=hlid(arealm.workergroup_oid))
 
-                        wk = (node_oid, worker['id'])
-                        workers[wk] = worker
+                        workers[(node_oid, worker['id'])] = worker
                 else:
                     self.log.warn('{func} Web cluster node {node_oid} not running [status={status}]',
                                   func=hltype(self._check_and_apply),
@@ -437,19 +437,6 @@ def _check_and_apply(self):
             self.log.failure()
 
         self._workers = workers
-        for node_oid, worker_id in self._workers:
-            worker = self._workers[(node_oid, worker_id)]
-            if worker:
-                status = worker['status'].upper()
-            else:
-                status = 'MISSING'
-            self.log.info(
-                '{func} webcluster {webcluster_oid} worker {worker_id} on node {node_oid} has status {status}',
-                func=hltype(self._check_and_apply),
-                worker_id=hlid(worker_id),
-                node_oid=hlid(node_oid),
-                webcluster_oid=hlid(self._webcluster_oid),
-                status=hlval(status))
 
         if is_running_completely:
             color = 'green'

crossbar/router/auth/cryptosign.py

@@ -291,13 +291,6 @@ def hello(self, realm: str, details: HelloDetails) -> Union[Accept, Deny, Challe
                 with self._principals_lock:
                     principals = self._config.get('principals', {})
 
-                    self.log.info(
-                        '{func} Looking up authid "{authid}" in principals database with {count} entries: {available_authids}',
-                        func=hltype(self.hello),
-                        authid=hlid(self._authid),
-                        count=len(principals),
-                        available_authids=list(principals.keys()))
-                    
                     if self._authid in principals:
                         principal = principals[self._authid]
                         if pubkey and (pubkey not in principal['authorized_keys']):

crossbar/worker/router.py

@@ -1109,12 +1109,6 @@ def update_router_transport_principals(self, transport_id, principals, details=N
         :returns: Dict with update status and principal count.
         :rtype: dict
         """
-        self.log.info(
-            '{method} Hot-updating principals for transport "{transport_id}" with {count} principals',
-            transport_id=hlid(transport_id),
-            count=hlval(len(principals), color='green'),
-            method=hltype(self.update_router_transport_principals))
-
         if transport_id not in self.transports:
             emsg = 'Cannot update transport principals: no transport with ID "{}"'.format(transport_id)
             self.log.error(emsg)
@@ -1139,44 +1133,27 @@ def update_router_transport_principals(self, transport_id, principals, details=N
         # Update the principals in the transport factory's auth config
         # This config is what gets passed to PendingAuthCryptosign instances
         if 'auth' not in factory._config:
-            self.log.warn(
-                '{method} Transport "{transport_id}" has no auth configuration in factory._config. Factory config keys: {config_keys}',
-                transport_id=hlid(transport_id),
-                config_keys=list(factory._config.keys()) if isinstance(factory._config, dict) else type(factory._config),
-                method=hltype(self.update_router_transport_principals))
             emsg = 'Transport "{}" has no auth configuration'.format(transport_id)
+            self.log.error(emsg)
             raise ApplicationError('crossbar.error.invalid_configuration', emsg)
 
         auth_config = factory._config['auth']
 
-        self.log.info(
-            '{method} Transport "{transport_id}" auth config has methods: {auth_methods}',
-            transport_id=hlid(transport_id),
-            auth_methods=list(auth_config.keys()) if isinstance(auth_config, dict) else type(auth_config),
-            method=hltype(self.update_router_transport_principals))
-        
         updated_count = 0
         updated_methods = []
 
         # Update principals for all cryptosign-* auth methods
         for authmethod in ['cryptosign-proxy']:
             if authmethod in auth_config:
-                old_principals = auth_config[authmethod].get('principals', {})
-                self.log.info(
-                    '{method} Updating "{authmethod}" - before: {old_authids}, after: {new_authids}',
-                    authmethod=hlid(authmethod),
-                    old_authids=list(old_principals.keys()) if isinstance(old_principals, dict) else 'N/A',
-                    new_authids=list(principals.keys()),
-                    method=hltype(self.update_router_transport_principals))
-                
                 auth_config[authmethod]['principals'] = principals
                 updated_count += 1
                 updated_methods.append(authmethod)
 
                 self.log.info(
-                    '{method} Updated auth method "{authmethod}" in transport "{transport_id}" with principals: {principal_authids}',
+                    '{method} Updated auth method "{authmethod}" in transport "{transport_id}" with {count} principals: {principal_authids}',
                     authmethod=hlid(authmethod),
                     transport_id=hlid(transport_id),
+                    count=len(principals),
                     principal_authids=hlval(list(principals.keys()), color='green'),
                     method=hltype(self.update_router_transport_principals))