v13.17.3

changelog.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 2026-04-13 - 13.17.3 - fix(ops-view-routes)
+sync route filter toggle selection via component changeSubject
+
+- Replaces the inline change handler on the route filter toggle with a subscription to the component's changeSubject in firstUpdated.
+- Ensures switching between user and system routes updates the view reliably and is cleaned up through existing rxSubscriptions management.
+
+## 2026-04-13 - 13.17.2 - fix(monitoring)
+exclude unconfigured routes from domain activity aggregation
+
+- Removes fallback aggregation that reported routes without domain configuration as synthetic domain entries based on route names
+- Keeps domain activity focused on configured domain mappings when splitting connection and throughput metrics
+
+## 2026-04-13 - 13.17.1 - fix(monitoring)
+stop allocating route metrics to domains when no request data exists
+
+- Removes the equal-split fallback for shared routes in MetricsManager.
+- Sets the proportional share to zero when a route has no recorded requests, avoiding inflated per-domain connection and throughput totals.
+
+## 2026-04-13 - 13.17.0 - feat(monitoring,network-ui,routes)
+add request-based domain activity metrics and split routes into user and system views
+
+- Domain activity now includes per-domain request counts and distributes route throughput and connections using request-level metrics instead of equal route sharing.
+- Network activity UI displays request counts and updates the domain activity description to reflect request-level aggregation.
+- Routes UI adds a toggle to filter between user-created and system-generated routes, updates summary card labels, and adjusts empty states accordingly.
+
 ## 2026-04-13 - 13.16.2 - fix(deps)
 bump @push.rocks/smartproxy to ^27.6.0
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "13.16.2",
+  "version": "13.17.3",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "exports": {

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '13.16.2',
+  version: '13.17.3',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

ts/monitoring/classes.metricsmanager.ts

@@ -560,7 +560,7 @@ export class MetricsManager {
           requestsPerSecond: 0,
           requestsTotal: 0,
           backends: [] as Array<any>,
-          domainActivity: [] as Array<{ domain: string; bytesInPerSecond: number; bytesOutPerSecond: number; activeConnections: number; routeCount: number }>,
+          domainActivity: [] as Array<{ domain: string; bytesInPerSecond: number; bytesOutPerSecond: number; activeConnections: number; routeCount: number; requestCount: number }>,
         };
       }
 
@@ -720,11 +720,20 @@ export class MetricsManager {
         .slice(0, 10)
         .map(([ip, data]) => ({ ip, count: data.count, bwIn: data.bwIn, bwOut: data.bwOut }));
 
-      // Build domain activity from per-route metrics
+      // Build domain activity using per-IP domain request counts from Rust engine
       const connectionsByRoute = proxyMetrics.connections.byRoute();
       const throughputByRoute = proxyMetrics.throughput.byRoute();
 
-      // Map route name → ALL its domains (not just the first one)
+      // Aggregate per-IP domain request counts into per-domain totals
+      const domainRequestTotals = new Map<string, number>();
+      const domainRequestsByIP = proxyMetrics.connections.domainRequestsByIP();
+      for (const [, domainMap] of domainRequestsByIP) {
+        for (const [domain, count] of domainMap) {
+          domainRequestTotals.set(domain, (domainRequestTotals.get(domain) || 0) + count);
+        }
+      }
+
+      // Map route name → domains from route config
       const routeDomains = new Map<string, string[]>();
       if (this.dcRouter.smartProxy) {
         for (const route of this.dcRouter.smartProxy.routeManager.getRoutes()) {
@@ -738,34 +747,26 @@ export class MetricsManager {
         }
       }
 
-      // Use protocol cache to discover actual active domains (resolves wildcards)
+      // Resolve wildcards using domains seen in request metrics
-      const activeDomains = new Set<string>();
+      const allKnownDomains = new Set<string>(domainRequestTotals.keys());
-      const domainToBackend = new Map<string, string>(); // domain → host:port
       for (const entry of protocolCache) {
-        if (entry.domain) {
+        if (entry.domain) allKnownDomains.add(entry.domain);
-          activeDomains.add(entry.domain);
-          domainToBackend.set(entry.domain, `${entry.host}:${entry.port}`);
-        }
       }
 
-      // Build reverse map: domain → route name(s) that handle it
+      // Build reverse map: concrete domain → route name(s)
-      // For concrete domains: direct lookup from route config
-      // For wildcard patterns: match active domains from protocol cache
       const domainToRoutes = new Map<string, string[]>();
       for (const [routeName, domains] of routeDomains) {
         for (const pattern of domains) {
           if (pattern.includes('*')) {
-            // Wildcard pattern — match against active domains from protocol cache
             const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '[^.]+') + '$');
-            for (const activeDomain of activeDomains) {
+            for (const knownDomain of allKnownDomains) {
-              if (regex.test(activeDomain)) {
+              if (regex.test(knownDomain)) {
-                const existing = domainToRoutes.get(activeDomain);
+                const existing = domainToRoutes.get(knownDomain);
                 if (existing) { existing.push(routeName); }
-                else { domainToRoutes.set(activeDomain, [routeName]); }
+                else { domainToRoutes.set(knownDomain, [routeName]); }
               }
             }
           } else {
-            // Concrete domain
             const existing = domainToRoutes.get(pattern);
             if (existing) { existing.push(routeName); }
             else { domainToRoutes.set(pattern, [routeName]); }
@@ -773,37 +774,40 @@ export class MetricsManager {
         }
       }
 
-      // Aggregate metrics per domain
+      // For each route, compute the total request count across all its resolved domains
-      // For each domain, sum metrics from all routes that serve it,
+      // so we can distribute throughput/connections proportionally
-      // divided by the number of domains each route serves
+      const routeTotalRequests = new Map<string, number>();
+      for (const [domain, routeNames] of domainToRoutes) {
+        const reqs = domainRequestTotals.get(domain) || 0;
+        for (const routeName of routeNames) {
+          routeTotalRequests.set(routeName, (routeTotalRequests.get(routeName) || 0) + reqs);
+        }
+      }
+
+      // Aggregate metrics per domain using request-count-proportional splitting
       const domainAgg = new Map<string, {
         activeConnections: number;
         bytesInPerSec: number;
         bytesOutPerSec: number;
         routeCount: number;
+        requestCount: number;
       }>();
 
-      // Track which routes are accounted for
-      const accountedRoutes = new Set<string>();
-
       for (const [domain, routeNames] of domainToRoutes) {
+        const domainReqs = domainRequestTotals.get(domain) || 0;
         let totalConns = 0;
         let totalIn = 0;
         let totalOut = 0;
 
         for (const routeName of routeNames) {
-          accountedRoutes.add(routeName);
           const conns = connectionsByRoute.get(routeName) || 0;
           const tp = throughputByRoute.get(routeName) || { in: 0, out: 0 };
-          // Count how many resolved domains share this route
+          const routeTotal = routeTotalRequests.get(routeName) || 0;
-          let domainsInRoute = 0;
+
-          for (const [, routes] of domainToRoutes) {
+          const share = routeTotal > 0 ? domainReqs / routeTotal : 0;
-            if (routes.includes(routeName)) domainsInRoute++;
+          totalConns += conns * share;
-          }
+          totalIn += tp.in * share;
-          const share = Math.max(domainsInRoute, 1);
+          totalOut += tp.out * share;
-          totalConns += conns / share;
-          totalIn += tp.in / share;
-          totalOut += tp.out / share;
         }
 
         domainAgg.set(domain, {
@@ -811,31 +815,10 @@ export class MetricsManager {
           bytesInPerSec: totalIn,
           bytesOutPerSec: totalOut,
           routeCount: routeNames.length,
+          requestCount: domainReqs,
         });
       }
 
-      // Include routes with no domain config (fallback: use route name)
-      for (const [routeName, activeConns] of connectionsByRoute) {
-        if (accountedRoutes.has(routeName)) continue;
-        if (routeDomains.has(routeName)) continue; // has domains but no traffic matched
-        const tp = throughputByRoute.get(routeName) || { in: 0, out: 0 };
-        if (activeConns === 0 && tp.in === 0 && tp.out === 0) continue;
-        const existing = domainAgg.get(routeName);
-        if (existing) {
-          existing.activeConnections += activeConns;
-          existing.bytesInPerSec += tp.in;
-          existing.bytesOutPerSec += tp.out;
-          existing.routeCount++;
-        } else {
-          domainAgg.set(routeName, {
-            activeConnections: activeConns,
-            bytesInPerSec: tp.in,
-            bytesOutPerSec: tp.out,
-            routeCount: 1,
-          });
-        }
-      }
-
       const domainActivity = Array.from(domainAgg.entries())
         .map(([domain, data]) => ({
           domain,
@@ -843,6 +826,7 @@ export class MetricsManager {
           bytesOutPerSecond: data.bytesOutPerSec,
           activeConnections: data.activeConnections,
           routeCount: data.routeCount,
+          requestCount: data.requestCount,
         }))
         .sort((a, b) => (b.bytesInPerSecond + b.bytesOutPerSecond) - (a.bytesInPerSecond + a.bytesOutPerSecond));
 

ts_interfaces/data/stats.ts

@@ -149,6 +149,7 @@ export interface IDomainActivity {
   bytesOutPerSecond: number;
   activeConnections: number;
   routeCount: number;
+  requestCount: number;
 }
 
 export interface INetworkMetrics {

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '13.16.2',
+  version: '13.17.3',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

ts_web/elements/network/ops-view-network-activity.ts

@@ -560,11 +560,12 @@ export class OpsViewNetworkActivity extends DeesElement {
             'Throughput Out': this.formatBitsPerSecond(item.bytesOutPerSecond),
             'Transferred / min': this.formatBytes(totalBytesPerMin),
             'Connections': item.activeConnections,
+            'Requests': item.requestCount?.toLocaleString() ?? '0',
             'Routes': item.routeCount,
           };
         }}
         heading1="Domain Activity"
-        heading2="Per-domain network activity aggregated from route metrics"
+        heading2="Per-domain network activity from request-level metrics"
         searchable
         .showColumnFilters=${true}
         .pagination=${false}

ts_web/elements/network/ops-view-routes.ts

@@ -49,6 +49,8 @@ function setupTlsVisibility(formEl: any) {
 
 @customElement('ops-view-routes')
 export class OpsViewRoutes extends DeesElement {
+  @state() accessor routeFilter: 'User Routes' | 'System Routes' = 'User Routes';
+
   @state() accessor routeState: appstate.IRouteManagementState = {
     mergedRoutes: [],
     warnings: [],
@@ -156,20 +158,20 @@ export class OpsViewRoutes extends DeesElement {
       },
       {
         id: 'configRoutes',
-        title: 'From Config',
+        title: 'System Routes',
         type: 'number',
         value: configCount,
         icon: 'lucide:settings',
-        description: 'Seeded from config/email/DNS',
+        description: 'From config, email, and DNS',
         color: '#8b5cf6',
       },
       {
         id: 'apiRoutes',
-        title: 'API Created',
+        title: 'User Routes',
         type: 'number',
         value: apiCount,
         icon: 'lucide:code',
-        description: 'Routes added via API',
+        description: 'Created via API',
         color: '#0ea5e9',
       },
       {
@@ -183,8 +185,14 @@ export class OpsViewRoutes extends DeesElement {
       },
     ];
 
-    // Map merged routes to sz-route-list-view format
+    // Filter routes based on selected tab
-    const szRoutes = mergedRoutes.map((mr) => {
+    const isUserRoutes = this.routeFilter === 'User Routes';
+    const filteredRoutes = mergedRoutes.filter((mr) =>
+      isUserRoutes ? mr.origin === 'api' : mr.origin !== 'api'
+    );
+
+    // Map filtered routes to sz-route-list-view format
+    const szRoutes = filteredRoutes.map((mr) => {
       const tags = [...(mr.route.tags || [])];
       tags.push(mr.origin);
       if (!mr.enabled) tags.push('disabled');
@@ -218,6 +226,13 @@ export class OpsViewRoutes extends DeesElement {
           ]}
         ></dees-statsgrid>
 
+        <dees-input-multitoggle
+          class="routeFilterToggle"
+          .type=${'single'}
+          .options=${['User Routes', 'System Routes']}
+          .selectedOption=${this.routeFilter}
+        ></dees-input-multitoggle>
+
         ${warnings.length > 0
           ? html`
               <div class="warnings-bar">
@@ -237,6 +252,7 @@ export class OpsViewRoutes extends DeesElement {
           ? html`
               <sz-route-list-view
                 .routes=${szRoutes}
+                .showActionsFilter=${isUserRoutes ? () => true : () => false}
                 @route-click=${(e: CustomEvent) => this.handleRouteClick(e)}
                 @route-edit=${(e: CustomEvent) => this.handleRouteEdit(e)}
                 @route-delete=${(e: CustomEvent) => this.handleRouteDelete(e)}
@@ -244,8 +260,8 @@ export class OpsViewRoutes extends DeesElement {
             `
           : html`
               <div class="empty-state">
-                <p>No routes configured</p>
+                <p>No ${isUserRoutes ? 'user' : 'system'} routes</p>
-                <p>Add a route to get started.</p>
+                <p>${isUserRoutes ? 'Add a route to get started.' : 'System routes are generated from config, email, and DNS settings.'}</p>
               </div>
             `}
       </div>
@@ -661,5 +677,13 @@ export class OpsViewRoutes extends DeesElement {
 
   async firstUpdated() {
     await appstate.routeManagementStatePart.dispatchAction(appstate.fetchMergedRoutesAction, null);
+
+    const toggle = this.shadowRoot!.querySelector('.routeFilterToggle') as any;
+    if (toggle) {
+      const sub = toggle.changeSubject.subscribe(() => {
+        this.routeFilter = toggle.selectedOption;
+      });
+      this.rxSubscriptions.push(sub);
+    }
   }
 }