v0.7.33 - Refactor monitoring system to use subscription-based activation with ephemeral events - fixes recursive crash bug

v0.7.32 - Implement ephemeral event bypass (NIP-01) - events with kinds 20000-29999 are now broadcast to subscriptions but never stored in database, preventing recursive monitoring event loops
v0.7.31 - Fixed production crash by replacing in-memory subscription iteration with database queries in monitoring system
2025-10-19 10:26:09 -04:00 · 2025-10-19 09:38:02 -04:00 · 2025-10-18 18:09:13 -04:00 · 2025-10-18 15:04:45 -04:00 · 2025-10-18 14:57:34 -04:00 · 2025-10-18 14:55:51 -04:00
25 changed files with 4351 additions and 127 deletions
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "c_utils_lib"]
 	path = c_utils_lib
 	url = ssh://git@git.laantungir.net:2222/laantungir/c_utils_lib.git
+[submodule "text_graph"]
+	path = text_graph
+	url = ssh://git@git.laantungir.net:2222/laantungir/text_graph.git
--- a/api/index.css
+++ b/api/index.css
@@ -85,6 +85,8 @@ body {
 .relay-info {
    text-align: center;
    flex: 1;
+    max-width: 150px;
+    margin: 0 auto;
 }

 .relay-name {
@@ -102,6 +104,8 @@ body {
    cursor: pointer;
    transition: border-color 0.2s ease;
    background-color: var(--secondary-color);
+    display: inline-block;
+    width: fit-content;
 }

 .relay-pubkey-container:hover {
@@ -132,6 +136,10 @@ body {
    font-size: 10px;
    color: var(--primary-color);
    margin-bottom: 0;
+    display: inline-block;
+    width: fit-content;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
 }

 .header-title {
@@ -180,7 +188,7 @@ body {
    padding: 8px 12px;
    border-radius: var(--border-radius);
    transition: background-color 0.2s ease;
-    margin-left: auto;
+    /* margin-left: auto; */
 }

 .admin-label {
@@ -297,6 +305,8 @@ h2 {
    border-radius: var(--border-radius);
    padding: 20px;
    margin-bottom: 20px;
+    margin-left: 5px;
+    margin-right:5px;
 }

 .input-group {
@@ -545,6 +555,7 @@ button:disabled {
 .inline-buttons {
    display: flex;
    gap: 10px;
+    flex-wrap: nowrap;
 }

 .inline-buttons button {
@@ -655,9 +666,9 @@ button:disabled {
    display: flex;
    justify-content: space-between;
    align-items: center;
-    margin-bottom: 15px;
-    border-bottom: var(--border-width) solid var(--border-color);
-    padding-bottom: 10px;
+    /* margin-bottom: 15px; */
+    /* border-bottom: var(--border-width) solid var(--border-color); */
+    /* padding-bottom: 10px; */
 }

 .countdown-btn {
@@ -1002,34 +1013,99 @@ body.dark-mode .sql-results-table tbody tr:nth-child(even) {
    background-color: rgba(255, 255, 255, 0.02);
 }

-@media (max-width: 700px) {
-    body {
-        padding: 10px;
-    }

-    .inline-buttons {
-        flex-direction: column;
-    }
+/* Config Toggle Button Styles */
+.config-toggle-btn {
+    width: 24px;
+    height: 24px;
+    padding: 0;
+    background: var(--secondary-color);
+    border: var(--border-width) solid var(--border-color);
+    border-radius: var(--border-radius);
+    font-family: var(--font-family);
+    font-size: 14px;
+    cursor: pointer;
+    margin-left: 10px;
+    font-weight: bold;
+    transition: all 0.2s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}

-    .query-actions {
-        flex-direction: column;
-    }
+/* Toggle Button Styles */
+.toggle-btn {
+    width: auto;
+    min-width: 120px;
+    padding: 8px 12px;
+    background: var(--secondary-color);
+    color: var(--primary-color);
+    border: var(--border-width) solid var(--border-color);
+    border-radius: var(--border-radius);
+    font-family: var(--font-family);
+    font-size: 12px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    margin-left: auto;
+}

-    h1 {
-        font-size: 20px;
-    }
+.toggle-btn:hover {
+    border-color: var(--accent-color);
+}

-    h2 {
-        font-size: 14px;
-    }
+.toggle-btn:active {
+    background: var(--accent-color);
+    color: var(--secondary-color);
+}

-    .sql-results-table {
-        font-size: 10px;
-    }
+.config-toggle-btn:hover {
+    border-color: var(--accent-color);
+}

-    .sql-results-table th,
-    .sql-results-table td {
-        padding: 4px 6px;
-        max-width: 120px;
-    }
-}
+.config-toggle-btn:active {
+    background: var(--accent-color);
+    color: var(--secondary-color);
+}
+
+.config-toggle-btn[data-state="true"] {
+    color: var(--accent-color);
+}
+
+.config-toggle-btn[data-state="false"] {
+    color: var(--primary-color);
+}
+
+.config-toggle-btn[data-state="indeterminate"] {
+    background-color: var(--muted-color);
+    color: var(--primary-color);
+    cursor: not-allowed;
+    border-color: var(--muted-color);
+   
+}
+
+
+/* ================================
+   REAL-TIME EVENT RATE CHART
+   ================================ */
+
+.chart-container {
+    margin: 20px 0;
+    padding: 15px;
+    background: var(--secondary-color);
+    border: var(--border-width) solid var(--border-color);
+    border-radius: var(--border-radius);
+}
+
+#event-rate-chart {
+    font-family: var(--font-family);
+    font-size: 12px;
+    line-height: 1.2;
+    color: var(--primary-color);
+    background: var(--secondary-color);
+    padding: 20px;
+    overflow: hidden;
+    white-space: pre;
+    border: var(--border-width) solid var(--border-color);
+    border-radius: var(--border-radius);
+    box-sizing: border-box;
+}
--- a/api/index.html
+++ b/api/index.html
@@ -54,9 +54,12 @@
    <div class="section flex-section" id="databaseStatisticsSection" style="display: none;">
        <div class="section-header">
            <h2>DATABASE STATISTICS</h2>
-            <button type="button" id="refresh-stats-btn" class="countdown-btn"></button>
+            <!-- Monitoring is now subscription-based - no toggle button needed -->
+            <!-- Subscribe to kind 24567 events to receive real-time monitoring data -->
        </div>

+        <!-- Event Rate Graph Container -->
+        <div id="event-rate-chart"></div>

        <!-- Database Overview Table -->
        <div class="input-group">
@@ -77,6 +80,10 @@
                            <td>Total Events</td>
                            <td id="total-events">-</td>
                        </tr>
+                        <tr>
+                            <td>Active Subscriptions</td>
+                            <td id="active-subscriptions">-</td>
+                        </tr>
                        <tr>
                            <td>Oldest Event</td>
                            <td id="oldest-event">-</td>
@@ -164,6 +171,35 @@

    </div>

+    <!-- SUBSCRIPTION DETAILS Section (Admin Only) -->
+    <div class="section flex-section" id="subscriptionDetailsSection" style="display: none;">
+        <div class="section-header">
+            <h2>ACTIVE SUBSCRIPTION DETAILS</h2>
+        </div>
+
+        <div class="input-group">
+            <div class="config-table-container">
+                <table class="config-table" id="subscription-details-table">
+                    <thead>
+                        <tr>
+                            <th>Subscription ID</th>
+                            <th>Client IP</th>
+                            <th>Duration</th>
+                            <th>Events Sent</th>
+                            <th>Status</th>
+                            <th>Filters</th>
+                        </tr>
+                    </thead>
+                    <tbody id="subscription-details-table-body">
+                        <tr>
+                            <td colspan="6" style="text-align: center; font-style: italic;">No subscriptions active</td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+
    <!-- Testing Section -->
    <div id="div_config" class="section flex-section" style="display: none;">
        <h2>RELAY CONFIGURATION</h2>
@@ -307,9 +343,11 @@

        <!-- Query Actions -->
        <div class="input-group">
-            <button type="button" id="execute-sql-btn" class="primary-button">EXECUTE QUERY</button>
-            <button type="button" id="clear-sql-btn">CLEAR</button>
-            <button type="button" id="clear-history-btn" class="danger-button">CLEAR HISTORY</button>
+            <div class="inline-buttons">
+                <button type="button" id="execute-sql-btn">EXECUTE QUERY</button>
+                <button type="button" id="clear-sql-btn">CLEAR</button>
+                <button type="button" id="clear-history-btn">CLEAR HISTORY</button>
+            </div>
        </div>

        <!-- Query Results -->
@@ -327,6 +365,8 @@
    <!-- Load NOSTR_LOGIN_LITE main library -->
    <!-- <script src="https://laantungir.net/nostr-login-lite/nostr-lite.js"></script> -->
    <script src="/api/nostr-lite.js"></script>
+    <!-- Load text_graph library -->
+    <script src="/api/text_graph.js"></script>



--- a/api/index.js
+++ b/api/index.js
@@ -37,6 +37,10 @@ let countdownSeconds = 10;
 // SQL Query state
 let pendingSqlQueries = new Map();

+// Real-time event rate chart
+let eventRateChart = null;
+let previousTotalEvents = 0; // Track previous total for rate calculation
+
 // DOM elements
 const loginModal = document.getElementById('login-modal');
 const loginModalContainer = document.getElementById('login-modal-container');
@@ -443,6 +447,9 @@ function handleAuthEvent(event) {
        // Automatically set up relay connection and show admin sections
        setupAutomaticRelayConnection(true);

+        // Auto-enable monitoring when admin logs in
+        autoEnableMonitoring();
+
    } else if (error) {
        console.log(`Authentication error: ${error}`);
    }
@@ -476,6 +483,7 @@ function updateAdminSectionsVisibility() {
    const divConfig = document.getElementById('div_config');
    const authRulesSection = document.getElementById('authRulesSection');
    const databaseStatisticsSection = document.getElementById('databaseStatisticsSection');
+    const subscriptionDetailsSection = document.getElementById('subscriptionDetailsSection');
    const nip17DMSection = document.getElementById('nip17DMSection');
    const sqlQuerySection = document.getElementById('sqlQuerySection');
    const shouldShow = isLoggedIn && isRelayConnected;
@@ -483,16 +491,17 @@ function updateAdminSectionsVisibility() {
    if (divConfig) divConfig.style.display = shouldShow ? 'block' : 'none';
    if (authRulesSection) authRulesSection.style.display = shouldShow ? 'block' : 'none';
    if (databaseStatisticsSection) databaseStatisticsSection.style.display = shouldShow ? 'block' : 'none';
+    if (subscriptionDetailsSection) subscriptionDetailsSection.style.display = shouldShow ? 'block' : 'none';
    if (nip17DMSection) nip17DMSection.style.display = shouldShow ? 'block' : 'none';
    if (sqlQuerySection) sqlQuerySection.style.display = shouldShow ? 'block' : 'none';

    // Start/stop auto-refresh based on visibility
    if (shouldShow && databaseStatisticsSection && databaseStatisticsSection.style.display === 'block') {
-        // Load statistics immediately, then start auto-refresh
+        // Load statistics immediately (no auto-refresh - using real-time monitoring events)
        sendStatsQuery().catch(error => {
            console.log('Auto-fetch statistics failed: ' + error.message);
        });
-        startStatsAutoRefresh();
+        // startStatsAutoRefresh(); // DISABLED - using real-time monitoring events instead
        // Also load configuration and auth rules automatically when sections become visible
        fetchConfiguration().catch(error => {
            console.log('Auto-fetch configuration failed: ' + error.message);
@@ -841,7 +850,7 @@ async function subscribeToConfiguration() {

        console.log(`Generated subscription ID: ${subscriptionId}`);
        console.log(`User pubkey ${userPubkey}`)
-        // Subscribe to kind 23457 events (admin response events), kind 4 (NIP-04 DMs), and kind 1059 (NIP-17 GiftWrap)
+        // Subscribe to kind 23457 events (admin response events), kind 4 (NIP-04 DMs), kind 1059 (NIP-17 GiftWrap), and kind 24567 (ephemeral monitoring events)
        const subscription = relayPool.subscribeMany([url], [{
            since: Math.floor(Date.now() / 1000) - 5,  // Look back 5 seconds to avoid race condition
            kinds: [23457],
@@ -859,6 +868,12 @@ async function subscribeToConfiguration() {
            kinds: [1059], // NIP-17 GiftWrap events
            "#p": [userPubkey], // Only GiftWrap events addressed to this user
            limit: 50
+        }, {
+            since: Math.floor(Date.now() / 1000), // Start from current time
+            kinds: [24567], // Real-time ephemeral monitoring events
+            authors: [getRelayPubkey()], // Only listen to monitoring events from the relay
+            "#d": isLoggedIn ? ["event_kinds", "time_stats", "top_pubkeys", "active_subscriptions", "subscription_details"] : ["event_kinds", "time_stats", "top_pubkeys", "active_subscriptions"], // Include subscription_details only when authenticated
+            limit: 50
        }], {
            async onevent(event) {
                console.log('=== EVENT RECEIVED VIA SIMPLEPOOL ===');
@@ -940,6 +955,15 @@ async function subscribeToConfiguration() {
                    // Process admin response event
                    processAdminResponse(event);
                }
+
+                // Handle monitoring events (kind 24567 - ephemeral)
+                if (event.kind === 24567) {
+                    console.log('=== MONITORING EVENT RECEIVED ===');
+                    console.log('Monitoring event:', event);
+
+                    // Process monitoring event
+                    processMonitoringEvent(event);
+                }
            },
            oneose() {
                console.log('EOSE received - End of stored events');
@@ -1019,6 +1043,184 @@ async function processAdminResponse(event) {
    }
 }

+// Initialize real-time event rate chart
+function initializeEventRateChart() {
+    try {
+        console.log('=== INITIALIZING EVENT RATE CHART ===');
+        
+        const chartContainer = document.getElementById('event-rate-chart');
+        console.log('Chart container found:', chartContainer);
+        
+        if (!chartContainer) {
+            console.log('Event rate chart container not found');
+            return;
+        }
+
+        // Show immediate placeholder content
+        chartContainer.textContent = 'Initializing event rate chart...';
+        console.log('Set placeholder content');
+
+        // Check if ASCIIBarChart is available
+        console.log('Checking ASCIIBarChart availability...');
+        console.log('typeof ASCIIBarChart:', typeof ASCIIBarChart);
+        console.log('window.ASCIIBarChart:', window.ASCIIBarChart);
+        
+        if (typeof ASCIIBarChart === 'undefined') {
+            console.log('ASCIIBarChart not available - text_graph.js may not be loaded');
+            // Show a more detailed error message
+            chartContainer.innerHTML = `
+                <div style="color: var(--accent-color); font-family: var(--font-family); padding: 10px;">
+                    ⚠️ Chart library not loaded<br>
+                    Check: /text_graph/text_graph.js<br>
+                    <small>Real-time event visualization unavailable</small>
+                </div>
+            `;
+            return;
+        }
+
+        // Create stub elements that the chart expects for info display
+        createChartStubElements();
+
+        console.log('Creating ASCIIBarChart instance...');
+        
+        // Initialize the chart with correct parameters based on text_graph.js API
+        eventRateChart = new ASCIIBarChart('event-rate-chart', {
+            maxHeight: 11,          // Chart height in lines
+            maxDataPoints: 76,      // Show last 76 bins (5+ minutes of history)
+            title: 'Events',       // Chart title
+            xAxisLabel: '',        // No X-axis label
+            yAxisLabel: '',        // No Y-axis label
+            autoFitWidth: true,    // Enable responsive font sizing
+            useBinMode: true,      // Enable time bin aggregation
+            binDuration: 4000,     // 4-second time bins
+            xAxisLabelFormat: 'elapsed' // Show elapsed time labels
+        });
+
+        console.log('ASCIIBarChart instance created:', eventRateChart);
+        console.log('Chart container content after init:', chartContainer.textContent);
+        console.log('Chart container innerHTML after init:', chartContainer.innerHTML);
+        
+        // Force an initial render
+        if (eventRateChart && typeof eventRateChart.render === 'function') {
+            console.log('Forcing initial render...');
+            eventRateChart.render();
+            console.log('Chart container content after render:', chartContainer.textContent);
+        }
+
+        console.log('Event rate chart initialized successfully');
+        log('Real-time event rate chart initialized', 'INFO');
+
+    } catch (error) {
+        console.error('Failed to initialize event rate chart:', error);
+        console.error('Error stack:', error.stack);
+        log(`Failed to initialize event rate chart: ${error.message}`, 'ERROR');
+        
+        // Show detailed error message in the container
+        const chartContainer = document.getElementById('event-rate-chart');
+        if (chartContainer) {
+            chartContainer.innerHTML = `
+                <div style="color: var(--error-color, #ff6b6b); font-family: var(--font-family); padding: 10px;">
+                    ❌ Chart initialization failed<br>
+                    <small>${error.message}</small><br>
+                    <small>Check browser console for details</small>
+                </div>
+            `;
+        }
+    }
+}
+
+// Create stub elements that the ASCIIBarChart expects for info display
+function createChartStubElements() {
+    const stubIds = ['values', 'max-value', 'scale', 'count'];
+    
+    stubIds.forEach(id => {
+        if (!document.getElementById(id)) {
+            const stubElement = document.createElement('div');
+            stubElement.id = id;
+            stubElement.style.display = 'none'; // Hide stub elements
+            document.body.appendChild(stubElement);
+        }
+    });
+    
+    console.log('Chart stub elements created');
+}
+
+// Handle monitoring events (kind 24567 - ephemeral)
+async function processMonitoringEvent(event) {
+    try {
+        console.log('=== PROCESSING MONITORING EVENT ===');
+        console.log('Monitoring event:', event);
+
+        // Verify this is a kind 24567 ephemeral monitoring event
+        if (event.kind !== 24567) {
+            console.log('Ignoring non-monitoring event, kind:', event.kind);
+            return;
+        }
+
+        // Verify the event is from the relay
+        const expectedRelayPubkey = getRelayPubkey();
+        if (event.pubkey !== expectedRelayPubkey) {
+            console.log('Ignoring monitoring event from unknown pubkey:', event.pubkey);
+            return;
+        }
+
+        // Check the d-tag to determine which type of monitoring event this is
+        const dTag = event.tags.find(tag => tag[0] === 'd');
+        if (!dTag) {
+            console.log('Ignoring monitoring event without d-tag');
+            return;
+        }
+
+        // Parse the monitoring data (content is JSON, not encrypted for monitoring events)
+        const monitoringData = JSON.parse(event.content);
+        console.log('Parsed monitoring data:', monitoringData);
+
+        // Don't add to chart here - we'll track actual event rate changes in updateStatsFromMonitoringEvent
+        console.log('Monitoring event received - will track rate changes in stats update');
+
+        // Route to appropriate handler based on d-tag
+        switch (dTag[1]) {
+            case 'event_kinds':
+                updateStatsFromMonitoringEvent(monitoringData);
+                log('Real-time event_kinds monitoring data updated', 'INFO');
+                break;
+
+            case 'time_stats':
+                updateStatsFromTimeMonitoringEvent(monitoringData);
+                log('Real-time time_stats monitoring data updated', 'INFO');
+                break;
+
+            case 'top_pubkeys':
+                updateStatsFromTopPubkeysMonitoringEvent(monitoringData);
+                log('Real-time top_pubkeys monitoring data updated', 'INFO');
+                break;
+
+            case 'active_subscriptions':
+                updateStatsFromActiveSubscriptionsMonitoringEvent(monitoringData);
+                log('Real-time active_subscriptions monitoring data updated', 'INFO');
+                break;
+
+            case 'subscription_details':
+                // Only process subscription details if user is authenticated
+                if (isLoggedIn) {
+                    updateStatsFromSubscriptionDetailsMonitoringEvent(monitoringData);
+                    log('Real-time subscription_details monitoring data updated', 'INFO');
+                } else {
+                    console.log('Ignoring subscription_details monitoring event - user not authenticated');
+                }
+                break;
+
+            default:
+                console.log('Ignoring monitoring event with unknown d-tag:', dTag[1]);
+                return;
+        }
+
+    } catch (error) {
+        console.error('Error processing monitoring event:', error);
+        log(`Failed to process monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
 // Handle different types of admin response data
 function handleAdminResponseData(responseData) {
    try {
@@ -1132,6 +1334,9 @@ function handleConfigQueryResponse(responseData) {
        // Update relay info in header with config data
        updateStoredRelayInfo(responseData);

+        // Initialize toggle buttons with config data
+        initializeToggleButtonsFromConfig(responseData);
+
        log(`Configuration loaded: ${responseData.total_results} parameters`, 'INFO');
    } else {
        console.log('No configuration data received');
@@ -2228,6 +2433,13 @@ async function saveAuthRule(event) {
    }
 }

+// Monitoring is now subscription-based - no auto-enable needed
+// Monitoring automatically activates when someone subscribes to kind 24567 events
+async function autoEnableMonitoring() {
+    log('Monitoring system is subscription-based - no manual enable needed', 'INFO');
+    log('Subscribe to kind 24567 events to receive real-time monitoring data', 'INFO');
+}
+
 // Update existing logout and showMainInterface functions to handle auth rules and NIP-17 DMs
 const originalLogout = logout;
 logout = async function () {
@@ -3277,12 +3489,13 @@ function updateRelayInfoInHeader() {
        }
    }

-    // Format npub into 3 lines of 21 characters each
+    // Format npub into 3 lines of 21 characters each, with spaces dividing each line into 3 groups of 7 characters
    let formattedNpub = relayNpub;
    if (relayNpub.length === 63) {
-        formattedNpub = relayNpub.substring(0, 21) + '\n' +
-                        relayNpub.substring(21, 42) + '\n' +
-                        relayNpub.substring(42, 63);
+        const line1 = relayNpub.substring(0, 7) + ' ' + relayNpub.substring(7, 14) + ' ' + relayNpub.substring(14, 21);
+        const line2 = relayNpub.substring(21, 28) + ' ' + relayNpub.substring(28, 35) + ' ' + relayNpub.substring(35, 42);
+        const line3 = relayNpub.substring(42, 49) + ' ' + relayNpub.substring(49, 56) + ' ' + relayNpub.substring(56, 63);
+        formattedNpub = line1 + '\n' + line2 + '\n' + line3;
    }

    relayNameElement.textContent = relayName;
@@ -3554,6 +3767,177 @@ function handleStatsQueryResponse(responseData) {
    }
 }

+// Update statistics display from real-time monitoring event
+function updateStatsFromMonitoringEvent(monitoringData) {
+    try {
+        log('Updating stats from monitoring event...', 'INFO');
+        console.log('Monitoring data:', monitoringData);
+
+        if (monitoringData.data_type !== 'event_kinds') {
+            log('Ignoring monitoring event with different data type', 'WARNING');
+            return;
+        }
+
+        // Update total events count and track rate for chart
+        if (monitoringData.total_events !== undefined) {
+            const currentTotal = monitoringData.total_events;
+            updateStatsCell('total-events', currentTotal.toString());
+            
+            // Calculate new events since last update for chart
+            if (previousTotalEvents > 0) {
+                const newEvents = currentTotal - previousTotalEvents;
+                if (newEvents > 0 && eventRateChart) {
+                    console.log(`Adding ${newEvents} new events to rate chart (${currentTotal} - ${previousTotalEvents})`);
+                    eventRateChart.addValue(newEvents);
+                }
+            }
+            
+            // Update previous total for next calculation
+            previousTotalEvents = currentTotal;
+        }
+
+        // Update event kinds table with real-time data
+        if (monitoringData.kinds && Array.isArray(monitoringData.kinds)) {
+            populateStatsKindsFromMonitoring(monitoringData.kinds, monitoringData.total_events);
+        }
+
+        log('Real-time statistics updated from monitoring event', 'INFO');
+
+    } catch (error) {
+        log(`Error updating stats from monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
+// Update statistics display from time_stats monitoring event
+function updateStatsFromTimeMonitoringEvent(monitoringData) {
+    try {
+        log('Updating time stats from monitoring event...', 'INFO');
+        console.log('Time monitoring data:', monitoringData);
+
+        if (monitoringData.data_type !== 'time_stats') {
+            log('Ignoring time monitoring event with different data type', 'WARNING');
+            return;
+        }
+
+        // Update time-based statistics table with real-time data
+        if (monitoringData.periods && Array.isArray(monitoringData.periods)) {
+            // Use the existing populateStatsTime function which expects the nested time_stats object
+            const timeStats = { last_24h: 0, last_7d: 0, last_30d: 0 };
+
+            // Extract values from periods array
+            monitoringData.periods.forEach(period => {
+                if (period.period === '24h') timeStats.last_24h = period.event_count;
+                else if (period.period === '7d') timeStats.last_7d = period.event_count;
+                else if (period.period === '30d') timeStats.last_30d = period.event_count;
+            });
+
+            populateStatsTime({ time_stats: timeStats });
+        }
+
+        log('Real-time time statistics updated from monitoring event', 'INFO');
+
+    } catch (error) {
+        log(`Error updating time stats from monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
+// Update statistics display from top_pubkeys monitoring event
+function updateStatsFromTopPubkeysMonitoringEvent(monitoringData) {
+    try {
+        log('Updating top pubkeys from monitoring event...', 'INFO');
+        console.log('Top pubkeys monitoring data:', monitoringData);
+
+        if (monitoringData.data_type !== 'top_pubkeys') {
+            log('Ignoring top pubkeys monitoring event with different data type', 'WARNING');
+            return;
+        }
+
+        // Update top pubkeys table with real-time data
+        if (monitoringData.pubkeys && Array.isArray(monitoringData.pubkeys)) {
+            // Pass total_events from monitoring data to the function
+            populateStatsPubkeysFromMonitoring(monitoringData.pubkeys, monitoringData.total_events || 0);
+        }
+
+        log('Real-time top pubkeys statistics updated from monitoring event', 'INFO');
+
+    } catch (error) {
+        log(`Error updating top pubkeys from monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
+// Update statistics display from active_subscriptions monitoring event
+function updateStatsFromActiveSubscriptionsMonitoringEvent(monitoringData) {
+    try {
+        log('Updating active subscriptions from monitoring event...', 'INFO');
+        console.log('Active subscriptions monitoring data:', monitoringData);
+
+        if (monitoringData.data_type !== 'active_subscriptions') {
+            log('Ignoring active subscriptions monitoring event with different data type', 'WARNING');
+            return;
+        }
+
+        // Update active subscriptions cell with real-time data
+        // The data is nested under monitoringData.data.total_subscriptions
+        if (monitoringData.data && monitoringData.data.total_subscriptions !== undefined) {
+            updateStatsCell('active-subscriptions', monitoringData.data.total_subscriptions.toString());
+        }
+
+        log('Real-time active subscriptions statistics updated from monitoring event', 'INFO');
+
+    } catch (error) {
+        log(`Error updating active subscriptions from monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
+// Update statistics display from subscription_details monitoring event
+function updateStatsFromSubscriptionDetailsMonitoringEvent(monitoringData) {
+    try {
+        log('Updating subscription details from monitoring event...', 'INFO');
+        console.log('Subscription details monitoring data:', monitoringData);
+
+        if (monitoringData.data_type !== 'subscription_details') {
+            log('Ignoring subscription details monitoring event with different data type', 'WARNING');
+            return;
+        }
+
+        // Update subscription details table with real-time data
+        if (monitoringData.data && Array.isArray(monitoringData.data.subscriptions)) {
+            populateSubscriptionDetailsTable(monitoringData.data.subscriptions);
+        }
+
+        log('Real-time subscription details statistics updated from monitoring event', 'INFO');
+
+    } catch (error) {
+        log(`Error updating subscription details from monitoring event: ${error.message}`, 'ERROR');
+    }
+}
+
+// Populate event kinds table from monitoring data
+function populateStatsKindsFromMonitoring(kindsData, totalEvents) {
+    const tableBody = document.getElementById('stats-kinds-table-body');
+    if (!tableBody) return;
+
+    tableBody.innerHTML = '';
+
+    if (kindsData.length === 0) {
+        const row = document.createElement('tr');
+        row.innerHTML = '<td colspan="3" style="text-align: center; font-style: italic;">No event data</td>';
+        tableBody.appendChild(row);
+        return;
+    }
+
+    kindsData.forEach(kind => {
+        const row = document.createElement('tr');
+        const percentage = totalEvents > 0 ? ((kind.count / totalEvents) * 100).toFixed(1) : '0.0';
+        row.innerHTML = `
+                    <td>${kind.kind}</td>
+                    <td>${kind.count}</td>
+                    <td>${percentage}%</td>
+                `;
+        tableBody.appendChild(row);
+    });
+}
+
 // Populate database overview table
 function populateStatsOverview(data) {
    if (!data) return;
@@ -3641,6 +4025,159 @@ function populateStatsPubkeys(data) {
    });
 }

+// Populate top pubkeys table from monitoring data
+function populateStatsPubkeysFromMonitoring(pubkeysData, totalEvents) {
+    const tableBody = document.getElementById('stats-pubkeys-table-body');
+    if (!tableBody || !pubkeysData || !Array.isArray(pubkeysData)) return;
+
+    tableBody.innerHTML = '';
+
+    if (pubkeysData.length === 0) {
+        const row = document.createElement('tr');
+        row.innerHTML = '<td colspan="4" style="text-align: center; font-style: italic;">No pubkey data</td>';
+        tableBody.appendChild(row);
+        return;
+    }
+
+    pubkeysData.forEach((pubkey, index) => {
+        const row = document.createElement('tr');
+        // Convert hex pubkey to npub for display
+        let displayPubkey = pubkey.pubkey || '-';
+        let npubLink = displayPubkey;
+        try {
+            if (pubkey.pubkey && pubkey.pubkey.length === 64 && /^[0-9a-fA-F]+$/.test(pubkey.pubkey)) {
+                const npub = window.NostrTools.nip19.npubEncode(pubkey.pubkey);
+                displayPubkey = npub;
+                npubLink = `<a href="https://njump.me/${npub}" target="_blank" class="npub-link">${npub}</a>`;
+            }
+        } catch (error) {
+            console.log('Failed to encode pubkey to npub:', error.message);
+        }
+
+        // Calculate percentage using totalEvents parameter
+        const percentage = totalEvents > 0 ? ((pubkey.event_count / totalEvents) * 100).toFixed(1) : '0.0';
+
+        row.innerHTML = `
+                    <td>${index + 1}</td>
+                    <td style="font-family: 'Courier New', monospace; font-size: 12px; word-break: break-all;">${npubLink}</td>
+                    <td>${pubkey.event_count}</td>
+                    <td>${percentage}%</td>
+                `;
+        tableBody.appendChild(row);
+    });
+}
+
+// Populate subscription details table from monitoring data
+function populateSubscriptionDetailsTable(subscriptionsData) {
+    const tableBody = document.getElementById('subscription-details-table-body');
+    if (!tableBody || !subscriptionsData || !Array.isArray(subscriptionsData)) return;
+
+    tableBody.innerHTML = '';
+
+    if (subscriptionsData.length === 0) {
+        const row = document.createElement('tr');
+        row.innerHTML = '<td colspan="6" style="text-align: center; font-style: italic;">No active subscriptions</td>';
+        tableBody.appendChild(row);
+        return;
+    }
+
+    subscriptionsData.forEach((subscription, index) => {
+        const row = document.createElement('tr');
+
+        // Calculate duration
+        const now = Math.floor(Date.now() / 1000);
+        const duration = now - subscription.created_at;
+        const durationStr = formatDuration(duration);
+
+        // Format client IP (show full IP for admin view)
+        const clientIP = subscription.client_ip || 'unknown';
+
+        // Format status
+        const status = subscription.active ? 'Active' : 'Inactive';
+
+        // Format filters (show actual filter details)
+        let filtersDisplay = 'None';
+        if (subscription.filters && subscription.filters.length > 0) {
+            const filterDetails = [];
+            subscription.filters.forEach((filter, index) => {
+                const parts = [];
+
+                // Add kinds if present
+                if (filter.kinds && Array.isArray(filter.kinds) && filter.kinds.length > 0) {
+                    parts.push(`kinds:[${filter.kinds.join(',')}]`);
+                }
+
+                // Add authors if present (truncate for display)
+                if (filter.authors && Array.isArray(filter.authors) && filter.authors.length > 0) {
+                    const authorCount = filter.authors.length;
+                    if (authorCount === 1) {
+                        const shortPubkey = filter.authors[0].substring(0, 8) + '...';
+                        parts.push(`authors:[${shortPubkey}]`);
+                    } else {
+                        parts.push(`authors:[${authorCount} pubkeys]`);
+                    }
+                }
+
+                // Add ids if present
+                if (filter.ids && Array.isArray(filter.ids) && filter.ids.length > 0) {
+                    const idCount = filter.ids.length;
+                    parts.push(`ids:[${idCount} event${idCount > 1 ? 's' : ''}]`);
+                }
+
+                // Add time range if present
+                const timeParts = [];
+                if (filter.since && filter.since > 0) {
+                    const sinceDate = new Date(filter.since * 1000).toLocaleString();
+                    timeParts.push(`since:${sinceDate}`);
+                }
+                if (filter.until && filter.until > 0) {
+                    const untilDate = new Date(filter.until * 1000).toLocaleString();
+                    timeParts.push(`until:${untilDate}`);
+                }
+                if (timeParts.length > 0) {
+                    parts.push(timeParts.join(', '));
+                }
+
+                // Add limit if present
+                if (filter.limit && filter.limit > 0) {
+                    parts.push(`limit:${filter.limit}`);
+                }
+
+                // Add tag filters if present
+                if (filter.tag_filters && Array.isArray(filter.tag_filters) && filter.tag_filters.length > 0) {
+                    parts.push(`tags:[${filter.tag_filters.length} filter${filter.tag_filters.length > 1 ? 's' : ''}]`);
+                }
+
+                if (parts.length > 0) {
+                    filterDetails.push(parts.join(', '));
+                } else {
+                    filterDetails.push('empty filter');
+                }
+            });
+
+            filtersDisplay = filterDetails.join(' | ');
+        }
+
+        row.innerHTML = `
+                    <td style="font-family: 'Courier New', monospace; font-size: 12px;">${subscription.id || 'N/A'}</td>
+                    <td style="font-family: 'Courier New', monospace; font-size: 12px;">${clientIP}</td>
+                    <td>${durationStr}</td>
+                    <td>${subscription.events_sent || 0}</td>
+                    <td>${status}</td>
+                    <td>${filtersDisplay}</td>
+                `;
+        tableBody.appendChild(row);
+    });
+}
+
+// Helper function to format duration in human-readable format
+function formatDuration(seconds) {
+    if (seconds < 60) return `${seconds}s`;
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+    return `${Math.floor(seconds / 86400)}d ${Math.floor((seconds % 86400) / 3600)}h`;
+}
+
 // Update statistics status indicator (disabled - status display removed)
 function updateStatsStatus(status, message = '') {
    // Status display has been removed from the UI
@@ -3682,43 +4219,9 @@ function updateStatsCell(cellId, newValue) {

 // Start auto-refreshing database statistics every 10 seconds
 function startStatsAutoRefresh() {
-    // Clear any existing interval
-    stopStatsAutoRefresh();
-
-    // Reset countdown
-    countdownSeconds = 10;
-    updateCountdownDisplay();
-
-    // Start countdown interval - update every second
-    countdownInterval = setInterval(() => {
-        countdownSeconds--;
-        updateCountdownDisplay();
-
-        if (countdownSeconds <= 0) {
-            // Time to refresh
-            if (isLoggedIn && isRelayConnected) {
-                log('Auto-refreshing database statistics...', 'INFO');
-                sendStatsQuery().then(() => {
-                    // Flash button red on successful refresh
-                    flashRefreshButton();
-                    // Reset countdown
-                    countdownSeconds = 10;
-                    updateCountdownDisplay();
-                }).catch(error => {
-                    log(`Auto-refresh failed: ${error.message}`, 'ERROR');
-                    // Reset countdown even on failure
-                    countdownSeconds = 10;
-                    updateCountdownDisplay();
-                });
-            } else {
-                // Reset countdown if not logged in/connected
-                countdownSeconds = 10;
-                updateCountdownDisplay();
-            }
-        }
-    }, 1000); // Update every 1 second
-
-    log('Database statistics auto-refresh started (10 second intervals)', 'INFO');
+    // DISABLED - Using real-time monitoring events instead of polling
+    // This function is kept for backward compatibility but no longer starts auto-refresh
+    log('Database statistics auto-refresh DISABLED - using real-time monitoring events', 'INFO');
 }

 // Stop auto-refreshing database statistics
@@ -3741,20 +4244,9 @@ function updateCountdownDisplay() {
    const refreshBtn = document.getElementById('refresh-stats-btn');
    if (!refreshBtn) return;

-    if (countdownInterval && isLoggedIn && isRelayConnected) {
-        // Japanese Kanji numbers: 〇 一 二 三 四 五 六 七 八 九 十
-        const kanjiNumbers = ['〇', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十'];
-
-        // Show single character counting down from 十 (10) to 〇 (0)
-        if (countdownSeconds >= 0 && countdownSeconds <= 10) {
-            refreshBtn.textContent = kanjiNumbers[countdownSeconds];
-        } else {
-            refreshBtn.textContent = '';
-        }
-    } else {
-        // Show empty when not active
-        refreshBtn.textContent = '';
-    }
+    // DISABLED - No countdown display when using real-time monitoring
+    // Show empty button text
+    refreshBtn.textContent = '';
 }

 // Flash refresh button red on successful refresh
@@ -3762,13 +4254,8 @@ function flashRefreshButton() {
    const refreshBtn = document.getElementById('refresh-stats-btn');
    if (!refreshBtn) return;

-    // Add red flash class
-    refreshBtn.classList.add('flash-red');
-
-    // Remove flash class after animation
-    setTimeout(() => {
-        refreshBtn.classList.remove('flash-red');
-    }, 500); // Match CSS animation duration
+    // DISABLED - No flashing when using real-time monitoring
+    // This function is kept for backward compatibility
 }

 // Event handlers for test buttons
@@ -3832,6 +4319,8 @@ document.addEventListener('DOMContentLoaded', () => {
        refreshStatsBtn.addEventListener('click', sendStatsQuery);
    }

+    // Subscription details section is always visible when authenticated
+
    // NIP-17 DM event handlers
    if (sendDmBtn) {
        sendDmBtn.addEventListener('click', sendNIP17DM);
@@ -3904,6 +4393,11 @@ document.addEventListener('DOMContentLoaded', () => {
    // Start RELAY letter animation
    startRelayAnimation();

+    // Initialize real-time event rate chart
+    setTimeout(() => {
+        initializeEventRateChart();
+    }, 1000); // Delay to ensure text_graph.js is loaded
+
    // Ensure admin sections are hidden by default on page load
    updateAdminSectionsVisibility();

@@ -4247,4 +4741,183 @@ function startRelayAnimation() {

    // Start the animation
    animateLetter();
-}
+}
+
+// ================================
+// CONFIG TOGGLE BUTTON COMPONENT
+// ================================
+
+// Global registry for config toggle buttons
+const configToggleButtons = new Map();
+
+// ConfigToggleButton class for tri-state boolean config toggles
+class ConfigToggleButton {
+    constructor(configKey, container, options = {}) {
+        this.configKey = configKey;
+        this.container = container;
+        this.state = 'false'; // Start in false state by default
+        this.pendingValue = null;
+        this.options = {
+            dataType: 'boolean',
+            category: 'monitoring',
+            ...options
+        };
+
+        this.render();
+        this.attachEventListeners();
+
+        // Register this button instance
+        configToggleButtons.set(configKey, this);
+    }
+
+    render() {
+        console.log('=== RENDERING CONFIG TOGGLE BUTTON ===');
+        console.log('Config key:', this.configKey);
+        console.log('Container:', this.container);
+
+        // Create button element
+        this.button = document.createElement('button');
+        this.button.className = 'config-toggle-btn';
+        this.button.setAttribute('data-config-key', this.configKey);
+        this.button.setAttribute('data-state', this.state);
+        this.button.setAttribute('title', `Toggle ${this.configKey}`);
+        this.updateIcon();
+
+        console.log('Button element created:', this.button);
+        console.log('Container before append:', this.container);
+        console.log('Container children before:', this.container.children.length);
+
+        this.container.appendChild(this.button);
+
+        console.log('Container children after:', this.container.children.length);
+        console.log('Button in DOM:', document.contains(this.button));
+    }
+
+    updateIcon() {
+        const icons = {
+            'true': 'I',
+            'false': '0',
+            'indeterminate': '⟳'
+        };
+        this.button.textContent = icons[this.state] || '?';
+    }
+
+    setState(newState) {
+        if (['true', 'false', 'indeterminate'].includes(newState)) {
+            this.state = newState;
+            this.button.setAttribute('data-state', newState);
+            this.updateIcon();
+        }
+    }
+
+    async toggle() {
+        console.log('=== TOGGLE BUTTON CLICKED ===');
+        console.log('Current state:', this.state);
+        console.log('Button element:', this.button);
+
+        if (this.state === 'indeterminate') {
+            console.log('Ignoring toggle - currently indeterminate');
+            return; // Don't toggle while pending
+        }
+
+        // Toggle between true and false
+        const newValue = this.state === 'true' ? 'false' : 'true';
+        this.pendingValue = newValue;
+
+        console.log('Sending toggle command:', newValue);
+
+        // Set to indeterminate while waiting
+        this.setState('indeterminate');
+
+        // Create config object
+        const configObj = {
+            key: this.configKey,
+            value: newValue,
+            data_type: this.options.dataType,
+            category: this.options.category
+        };
+
+        console.log('Config object:', configObj);
+
+        try {
+            // Send config update command
+            console.log('Sending config update command...');
+            await sendConfigUpdateCommand([configObj]);
+            console.log('Config update command sent successfully');
+            log(`Config toggle sent: ${this.configKey} = ${newValue}`, 'INFO');
+        } catch (error) {
+            console.log('Config update command failed:', error);
+            log(`Failed to send config toggle: ${error.message}`, 'ERROR');
+            // Revert to previous state on error
+            this.setState('false');
+            this.pendingValue = null;
+        }
+    }
+
+    handleResponse(success, actualValue) {
+        console.log('=== HANDLE RESPONSE ===');
+        console.log('Success:', success);
+        console.log('Actual value:', actualValue);
+        console.log('Pending value:', this.pendingValue);
+
+        if (success) {
+            console.log('Success - setting to actual server value:', actualValue);
+            this.setState(actualValue);
+        } else {
+            console.log('Failed - reverting to false state');
+            // Failed - revert to false state
+            this.setState('false');
+        }
+        this.pendingValue = null;
+        console.log('Pending value cleared');
+    }
+
+    attachEventListeners() {
+        this.button.addEventListener('click', () => this.toggle());
+    }
+}
+
+// Helper function to get a registered toggle button
+function getConfigToggleButton(configKey) {
+    return configToggleButtons.get(configKey);
+}
+
+// Monitoring is now subscription-based - no toggle button needed
+// Monitoring automatically activates when someone subscribes to kind 24567 events
+function initializeMonitoringToggleButton() {
+    console.log('=== MONITORING IS NOW SUBSCRIPTION-BASED ===');
+    console.log('No toggle button needed - monitoring activates automatically when subscribing to kind 24567');
+    log('Monitoring system is subscription-based - no manual toggle required', 'INFO');
+    return null;
+}
+
+// Monitoring is subscription-based - no toggle button response handling needed
+const originalHandleConfigUpdateResponse = handleConfigUpdateResponse;
+handleConfigUpdateResponse = function(responseData) {
+    console.log('=== CONFIG UPDATE RESPONSE HANDLER ===');
+    console.log('Response data:', responseData);
+
+    // Call original handler
+    originalHandleConfigUpdateResponse(responseData);
+
+    // Monitoring is now subscription-based - no toggle buttons to update
+    console.log('Monitoring system is subscription-based - no toggle buttons to handle');
+};
+
+// Monitoring is now subscription-based - no toggle buttons needed
+function initializeToggleButtonsFromConfig(configData) {
+    console.log('=== MONITORING IS SUBSCRIPTION-BASED ===');
+    console.log('No toggle buttons needed - monitoring activates automatically when subscribing to kind 24567');
+    log('Monitoring system initialized - subscription-based activation ready', 'INFO');
+}
+
+// Initialize toggle button after DOM is ready
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('=== DOM CONTENT LOADED - INITIALIZING TOGGLE BUTTON ===');
+
+    // Initialize the monitoring toggle button
+    setTimeout(() => {
+        console.log('=== SETTIMEOUT CALLBACK - CALLING initializeMonitoringToggleButton ===');
+        initializeMonitoringToggleButton();
+    }, 500); // Small delay to ensure DOM is fully ready
+});
--- a/api/text_graph.js
+++ b/api/text_graph.js
@@ -0,0 +1,470 @@
+/**
+ * ASCIIBarChart - A dynamic ASCII-based vertical bar chart renderer
+ * 
+ * Creates real-time animated bar charts using monospaced characters (X)
+ * with automatic scaling, labels, and responsive font sizing.
+ */
+class ASCIIBarChart {
+    /**
+     * Create a new ASCII bar chart
+     * @param {string} containerId - The ID of the HTML element to render the chart in
+     * @param {Object} options - Configuration options
+     * @param {number} [options.maxHeight=20] - Maximum height of the chart in rows
+     * @param {number} [options.maxDataPoints=30] - Maximum number of data columns before scrolling
+     * @param {string} [options.title=''] - Chart title (displayed centered at top)
+     * @param {string} [options.xAxisLabel=''] - X-axis label (displayed centered at bottom)
+     * @param {string} [options.yAxisLabel=''] - Y-axis label (displayed vertically on left)
+     * @param {boolean} [options.autoFitWidth=true] - Automatically adjust font size to fit container width
+     * @param {boolean} [options.useBinMode=false] - Enable time bin mode for data aggregation
+     * @param {number} [options.binDuration=10000] - Duration of each time bin in milliseconds (10 seconds default)
+     * @param {string} [options.xAxisLabelFormat='elapsed'] - X-axis label format: 'elapsed', 'bins', 'timestamps', 'ranges'
+     */
+    constructor(containerId, options = {}) {
+        this.container = document.getElementById(containerId);
+        this.data = [];
+        this.maxHeight = options.maxHeight || 20;
+        this.maxDataPoints = options.maxDataPoints || 30;
+        this.totalDataPoints = 0; // Track total number of data points added
+        this.title = options.title || '';
+        this.xAxisLabel = options.xAxisLabel || '';
+        this.yAxisLabel = options.yAxisLabel || '';
+        this.autoFitWidth = options.autoFitWidth !== false; // Default to true
+
+        // Time bin configuration
+        this.useBinMode = options.useBinMode !== false; // Default to true
+        this.binDuration = options.binDuration || 4000; // 4 seconds default
+        this.xAxisLabelFormat = options.xAxisLabelFormat || 'elapsed';
+
+        // Time bin data structures
+        this.bins = [];
+        this.currentBinIndex = -1;
+        this.binStartTime = null;
+        this.binCheckInterval = null;
+        this.chartStartTime = Date.now();
+
+        // Set up resize observer if auto-fit is enabled
+        if (this.autoFitWidth) {
+            this.resizeObserver = new ResizeObserver(() => {
+                this.adjustFontSize();
+            });
+            this.resizeObserver.observe(this.container);
+        }
+
+        // Initialize first bin if bin mode is enabled
+        if (this.useBinMode) {
+            this.initializeBins();
+        }
+    }
+    
+    /**
+     * Add a new data point to the chart
+     * @param {number} value - The numeric value to add
+     */
+    addValue(value) {
+        if (this.useBinMode) {
+            // Time bin mode: increment count in current active bin
+            this.checkBinRotation(); // Ensure we have an active bin
+            this.bins[this.currentBinIndex].count++;
+            this.totalDataPoints++;
+        } else {
+            // Legacy mode: add individual values
+            this.data.push(value);
+            this.totalDataPoints++;
+
+            // Keep only the most recent data points
+            if (this.data.length > this.maxDataPoints) {
+                this.data.shift();
+            }
+        }
+
+        this.render();
+        this.updateInfo();
+    }
+    
+    /**
+     * Clear all data from the chart
+     */
+    clear() {
+        this.data = [];
+        this.totalDataPoints = 0;
+
+        if (this.useBinMode) {
+            this.bins = [];
+            this.currentBinIndex = -1;
+            this.binStartTime = null;
+            this.initializeBins();
+        }
+
+        this.render();
+        this.updateInfo();
+    }
+    
+    /**
+     * Calculate the width of the chart in characters
+     * @returns {number} The chart width in characters
+     * @private
+     */
+    getChartWidth() {
+        let dataLength = this.maxDataPoints; // Always use maxDataPoints for consistent width
+
+        if (dataLength === 0) return 50; // Default width for empty chart
+
+        const yAxisPadding = this.yAxisLabel ? 2 : 0;
+        const yAxisNumbers = 3; // Width of Y-axis numbers
+        const separator = 1; // The '|' character
+        // const dataWidth = dataLength * 2; // Each column is 2 characters wide  // TEMP: commented for no-space test
+        const dataWidth = dataLength; // Each column is 1 character wide  // TEMP: adjusted for no-space columns
+        const padding = 1; // Extra padding
+
+        const totalWidth = yAxisPadding + yAxisNumbers + separator + dataWidth + padding;
+
+        // Only log when width changes
+        if (this.lastChartWidth !== totalWidth) {
+            console.log('getChartWidth changed:', { dataLength, totalWidth, previous: this.lastChartWidth });
+            this.lastChartWidth = totalWidth;
+        }
+
+        return totalWidth;
+    }
+    
+    /**
+     * Adjust font size to fit container width
+     * @private
+     */
+    adjustFontSize() {
+        if (!this.autoFitWidth) return;
+
+        const containerWidth = this.container.clientWidth;
+        const chartWidth = this.getChartWidth();
+
+        if (chartWidth === 0) return;
+
+        // Calculate optimal font size
+        // For monospace fonts, character width is approximately 0.6 * font size
+        // Use a slightly smaller ratio to fit more content
+        const charWidthRatio = 0.6;
+        const padding = 30; // Reduce padding to fit more content
+        const availableWidth = containerWidth - padding;
+        const optimalFontSize = Math.floor((availableWidth / chartWidth) / charWidthRatio);
+
+        // Set reasonable bounds (min 4px, max 20px)
+        const fontSize = Math.max(4, Math.min(20, optimalFontSize));
+
+        // Only log when font size changes
+        if (this.lastFontSize !== fontSize) {
+            console.log('fontSize changed:', { containerWidth, chartWidth, fontSize, previous: this.lastFontSize });
+            this.lastFontSize = fontSize;
+        }
+
+        this.container.style.fontSize = fontSize + 'px';
+        this.container.style.lineHeight = '1.0';
+    }
+    
+    /**
+     * Render the chart to the container
+     * @private
+     */
+    render() {
+        let dataToRender = [];
+        let maxValue = 0;
+        let minValue = 0;
+        let valueRange = 0;
+
+        if (this.useBinMode) {
+            // Bin mode: render bin counts
+            if (this.bins.length === 0) {
+                this.container.textContent = 'No data yet. Click Start to begin.';
+                return;
+            }
+            // Always create a fixed-length array filled with 0s, then overlay actual bin data
+            dataToRender = new Array(this.maxDataPoints).fill(0);
+
+            // Overlay actual bin data (most recent bins, reversed for left-to-right display)
+            const startIndex = Math.max(0, this.bins.length - this.maxDataPoints);
+            const recentBins = this.bins.slice(startIndex);
+
+            // Reverse the bins so most recent is on the left, and overlay onto the fixed array
+            recentBins.reverse().forEach((bin, index) => {
+                if (index < this.maxDataPoints) {
+                    dataToRender[index] = bin.count;
+                }
+            });
+
+            console.log('render() dataToRender:', dataToRender, 'bins length:', this.bins.length);
+            maxValue = Math.max(...dataToRender);
+            minValue = Math.min(...dataToRender);
+            valueRange = maxValue - minValue;
+        } else {
+            // Legacy mode: render individual values
+            if (this.data.length === 0) {
+                this.container.textContent = 'No data yet. Click Start to begin.';
+                return;
+            }
+            dataToRender = this.data;
+            maxValue = Math.max(...this.data);
+            minValue = Math.min(...this.data);
+            valueRange = maxValue - minValue;
+        }
+
+        let output = '';
+        const scale = this.maxHeight;
+
+        // Calculate scaling factor: each X represents at least 1 count
+        const maxCount = Math.max(...dataToRender);
+        const scaleFactor = Math.max(1, Math.ceil(maxCount / scale)); // 1 X = scaleFactor counts
+        const scaledMax = Math.ceil(maxCount / scaleFactor) * scaleFactor;
+
+        // Calculate Y-axis label width (for vertical text)
+        const yLabelWidth = this.yAxisLabel ? 2 : 0;
+        const yAxisPadding = this.yAxisLabel ? '  ' : '';
+
+        // Add title if provided (centered)
+         if (this.title) {
+             // const chartWidth = 4 + this.maxDataPoints * 2; // Y-axis numbers + data columns  // TEMP: commented for no-space test
+             const chartWidth = 4 + this.maxDataPoints; // Y-axis numbers + data columns  // TEMP: adjusted for no-space columns
+             const titlePadding = Math.floor((chartWidth - this.title.length) / 2);
+             output += yAxisPadding + ' '.repeat(Math.max(0, titlePadding)) + this.title + '\n\n';
+         }
+
+        // Draw from top to bottom
+        for (let row = scale; row > 0; row--) {
+            let line = '';
+
+            // Add vertical Y-axis label character
+            if (this.yAxisLabel) {
+                const L = this.yAxisLabel.length;
+                const startRow = Math.floor((scale - L) / 2) + 1;
+                const relativeRow = scale - row + 1; // 1 at top, scale at bottom
+                if (relativeRow >= startRow && relativeRow < startRow + L) {
+                    const labelIndex = relativeRow - startRow;
+                    line += this.yAxisLabel[labelIndex] + ' ';
+                } else {
+                    line += '  ';
+                }
+            }
+
+            // Calculate the actual count value this row represents (0 at bottom, increasing upward)
+            const rowCount = (row - 1) * scaleFactor;
+
+            // Add Y-axis label (show actual count values)
+            line += String(rowCount).padStart(3, ' ') + ' |';
+
+            // Draw each column
+            for (let i = 0; i < dataToRender.length; i++) {
+                const count = dataToRender[i];
+                const scaledHeight = Math.ceil(count / scaleFactor);
+
+                if (scaledHeight >= row) {
+                    // line += ' X';  // TEMP: commented out space between columns
+                    line += 'X';  // TEMP: no space between columns
+                } else {
+                    // line += '  ';  // TEMP: commented out space between columns
+                    line += ' ';  // TEMP: single space for empty columns
+                }
+            }
+
+            output += line + '\n';
+        }
+
+        // Draw X-axis
+         // output += yAxisPadding + '    +' + '-'.repeat(this.maxDataPoints * 2) + '\n';  // TEMP: commented out for no-space test
+         output += yAxisPadding + '    +' + '-'.repeat(this.maxDataPoints) + '\n';  // TEMP: back to original length
+
+        // Draw X-axis labels based on mode and format
+         let xAxisLabels = yAxisPadding + '     ';  // Initial padding to align with X-axis
+
+         // Determine label interval (every 5 columns)
+         const labelInterval = 5;
+
+         // Generate all labels first and store in array
+         let labels = [];
+         for (let i = 0; i < this.maxDataPoints; i++) {
+             if (i % labelInterval === 0) {
+                 let label = '';
+                 if (this.useBinMode) {
+                     // For bin mode, show labels for all possible positions
+                     // i=0 is leftmost (most recent), i=maxDataPoints-1 is rightmost (oldest)
+                     const elapsedSec = (i * this.binDuration) / 1000;
+                     // Format with appropriate precision for sub-second bins
+                     if (this.binDuration < 1000) {
+                         // Show decimal seconds for sub-second bins
+                         label = elapsedSec.toFixed(1) + 's';
+                     } else {
+                         // Show whole seconds for 1+ second bins
+                         label = String(Math.round(elapsedSec)) + 's';
+                     }
+                 } else {
+                     // For legacy mode, show data point numbers
+                     const startIndex = Math.max(1, this.totalDataPoints - this.maxDataPoints + 1);
+                     label = String(startIndex + i);
+                 }
+                 labels.push(label);
+             }
+         }
+
+         // Build the label string with calculated spacing
+         for (let i = 0; i < labels.length; i++) {
+             const label = labels[i];
+             xAxisLabels += label;
+
+             // Add spacing: labelInterval - label.length (except for last label)
+             if (i < labels.length - 1) {
+                 const spacing = labelInterval - label.length;
+                 xAxisLabels += ' '.repeat(spacing);
+             }
+         }
+
+         // Ensure the label line extends to match the X-axis dash line length
+         // The dash line is this.maxDataPoints characters long, starting after "    +"
+         const dashLineLength = this.maxDataPoints;
+         const minLabelLineLength = yAxisPadding.length + 4 + dashLineLength; // 4 for "    "
+         if (xAxisLabels.length < minLabelLineLength) {
+             xAxisLabels += ' '.repeat(minLabelLineLength - xAxisLabels.length);
+         }
+        output += xAxisLabels + '\n';
+
+        // Add X-axis label if provided
+         if (this.xAxisLabel) {
+             // const labelPadding = Math.floor((this.maxDataPoints * 2 - this.xAxisLabel.length) / 2);  // TEMP: commented for no-space test
+             const labelPadding = Math.floor((this.maxDataPoints - this.xAxisLabel.length) / 2);  // TEMP: adjusted for no-space columns
+             output += '\n' + yAxisPadding + '     ' + ' '.repeat(Math.max(0, labelPadding)) + this.xAxisLabel + '\n';
+         }
+
+        this.container.textContent = output;
+
+        // Adjust font size to fit width (only once at initialization)
+         if (this.autoFitWidth) {
+             this.adjustFontSize();
+         }
+
+        // Update the external info display
+        if (this.useBinMode) {
+            const binCounts = this.bins.map(bin => bin.count);
+            const scaleFactor = Math.max(1, Math.ceil(maxValue / scale));
+            document.getElementById('values').textContent = `[${dataToRender.join(', ')}]`;
+            document.getElementById('max-value').textContent = maxValue;
+            document.getElementById('scale').textContent = `Min: ${minValue}, Max: ${maxValue}, 1X=${scaleFactor} counts`;
+        } else {
+            document.getElementById('values').textContent = `[${this.data.join(', ')}]`;
+            document.getElementById('max-value').textContent = maxValue;
+            document.getElementById('scale').textContent = `Min: ${minValue}, Max: ${maxValue}, Height: ${scale}`;
+        }
+    }
+    
+    /**
+     * Update the info display
+     * @private
+     */
+    updateInfo() {
+        if (this.useBinMode) {
+            const totalCount = this.bins.reduce((sum, bin) => sum + bin.count, 0);
+            document.getElementById('count').textContent = totalCount;
+        } else {
+            document.getElementById('count').textContent = this.data.length;
+        }
+    }
+
+    /**
+     * Initialize the bin system
+     * @private
+     */
+    initializeBins() {
+        this.bins = [];
+        this.currentBinIndex = -1;
+        this.binStartTime = null;
+        this.chartStartTime = Date.now();
+
+        // Create first bin
+        this.rotateBin();
+
+        // Set up automatic bin rotation check
+        this.binCheckInterval = setInterval(() => {
+            this.checkBinRotation();
+        }, 100); // Check every 100ms for responsiveness
+    }
+
+    /**
+     * Check if current bin should rotate and create new bin if needed
+     * @private
+     */
+    checkBinRotation() {
+        if (!this.useBinMode || !this.binStartTime) return;
+
+        const now = Date.now();
+        if ((now - this.binStartTime) >= this.binDuration) {
+            this.rotateBin();
+        }
+    }
+
+    /**
+     * Rotate to a new bin, finalizing the current one
+     */
+    rotateBin() {
+        // Finalize current bin if it exists
+        if (this.currentBinIndex >= 0) {
+            this.bins[this.currentBinIndex].isActive = false;
+        }
+
+        // Create new bin
+        const newBin = {
+            startTime: Date.now(),
+            count: 0,
+            isActive: true
+        };
+
+        this.bins.push(newBin);
+        this.currentBinIndex = this.bins.length - 1;
+        this.binStartTime = newBin.startTime;
+
+        // Keep only the most recent bins
+        if (this.bins.length > this.maxDataPoints) {
+            this.bins.shift();
+            this.currentBinIndex--;
+        }
+
+        // Ensure currentBinIndex points to the last bin (the active one)
+        this.currentBinIndex = this.bins.length - 1;
+
+        // Force a render to update the display immediately
+        this.render();
+        this.updateInfo();
+    }
+
+    /**
+     * Format X-axis label for a bin based on the configured format
+     * @param {number} binIndex - Index of the bin
+     * @returns {string} Formatted label
+     * @private
+     */
+    formatBinLabel(binIndex) {
+        const bin = this.bins[binIndex];
+        if (!bin) return '  ';
+
+        switch (this.xAxisLabelFormat) {
+            case 'bins':
+                return String(binIndex + 1).padStart(2, ' ');
+
+            case 'timestamps':
+                const time = new Date(bin.startTime);
+                return time.toLocaleTimeString('en-US', {
+                    hour12: false,
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit'
+                }).replace(/:/g, '');
+
+            case 'ranges':
+                const startSec = Math.floor((bin.startTime - this.chartStartTime) / 1000);
+                const endSec = startSec + Math.floor(this.binDuration / 1000);
+                return `${startSec}-${endSec}`;
+
+            case 'elapsed':
+            default:
+                // For elapsed time, always show time relative to the first bin (index 0)
+                // This keeps the leftmost label as 0s and increases to the right
+                const firstBinTime = this.bins[0] ? this.bins[0].startTime : this.chartStartTime;
+                const elapsedSec = Math.floor((bin.startTime - firstBinTime) / 1000);
+                return String(elapsedSec).padStart(2, ' ') + 's';
+        }
+    }
+}
--- a/docs/monitoring_simplified_plan.md
+++ b/docs/monitoring_simplified_plan.md
@@ -0,0 +1,601 @@
+# Simplified Monitoring Implementation Plan
+## Kind 34567 Event Kind Distribution Reporting
+
+**Date:** 2025-10-16  
+**Status:** Implementation Ready
+
+---
+
+## Overview
+
+Simplified real-time monitoring system that:
+- Reports event kind distribution (which includes total event count)
+- Uses kind 34567 addressable events with `d=event_kinds`
+- Controlled by two config variables
+- Enabled on-demand when admin logs in
+- Uses simple throttling to prevent performance impact
+
+---
+
+## Configuration Variables
+
+### Database Config Table
+
+Add two new configuration keys:
+
+```sql
+INSERT INTO config (key, value, data_type, description, category) VALUES
+  ('kind_34567_reporting_enabled', 'false', 'boolean', 
+   'Enable/disable kind 34567 event kind distribution reporting', 'monitoring'),
+  ('kind_34567_reporting_throttling_sec', '5', 'integer', 
+   'Minimum seconds between kind 34567 reports (throttling)', 'monitoring');
+```
+
+### Configuration Access
+
+```c
+// In src/monitoring.c or src/api.c
+int is_monitoring_enabled(void) {
+    return get_config_bool("kind_34567_reporting_enabled", 0);
+}
+
+int get_monitoring_throttle_seconds(void) {
+    return get_config_int("kind_34567_reporting_throttling_sec", 5);
+}
+```
+
+---
+
+## Event Structure
+
+### Kind 34567 Event Format
+
+```json
+{
+  "id": "<event_id>",
+  "pubkey": "<relay_pubkey>",
+  "created_at": 1697123456,
+  "kind": 34567,
+  "content": "{\"data_type\":\"event_kinds\",\"timestamp\":1697123456,\"data\":{\"total_events\":125000,\"distribution\":[{\"kind\":1,\"count\":45000,\"percentage\":36.0},{\"kind\":3,\"count\":12500,\"percentage\":10.0}]}}",
+  "tags": [
+    ["d", "event_kinds"],
+    ["relay", "<relay_pubkey>"]
+  ],
+  "sig": "<signature>"
+}
+```
+
+### Content JSON Structure
+
+```json
+{
+  "data_type": "event_kinds",
+  "timestamp": 1697123456,
+  "data": {
+    "total_events": 125000,
+    "distribution": [
+      {
+        "kind": 1,
+        "count": 45000,
+        "percentage": 36.0
+      },
+      {
+        "kind": 3,
+        "count": 12500,
+        "percentage": 10.0
+      }
+    ]
+  },
+  "metadata": {
+    "query_time_ms": 18
+  }
+}
+```
+
+---
+
+## Implementation
+
+### File Structure
+
+```
+src/
+  monitoring.h          # New file - monitoring system header
+  monitoring.c          # New file - monitoring implementation
+  main.c               # Modified - add trigger hook
+  config.c             # Modified - add config keys (or use migration)
+```
+
+### 1. Header File: `src/monitoring.h`
+
+```c
+#ifndef MONITORING_H
+#define MONITORING_H
+
+#include <time.h>
+#include <cjson/cJSON.h>
+
+// Initialize monitoring system
+int init_monitoring_system(void);
+
+// Cleanup monitoring system
+void cleanup_monitoring_system(void);
+
+// Called when an event is stored (from main.c)
+void monitoring_on_event_stored(void);
+
+// Enable/disable monitoring (called from admin API)
+int set_monitoring_enabled(int enabled);
+
+// Get monitoring status
+int is_monitoring_enabled(void);
+
+// Get throttle interval
+int get_monitoring_throttle_seconds(void);
+
+#endif /* MONITORING_H */
+```
+
+### 2. Implementation: `src/monitoring.c`
+
+```c
+#include "monitoring.h"
+#include "config.h"
+#include "debug.h"
+#include "../nostr_core_lib/nostr_core/nostr_core.h"
+#include <sqlite3.h>
+#include <string.h>
+#include <time.h>
+
+// External references
+extern sqlite3* g_db;
+extern int broadcast_event_to_subscriptions(cJSON* event);
+extern int store_event(cJSON* event);
+extern const char* get_config_value(const char* key);
+extern int get_config_bool(const char* key, int default_value);
+extern int get_config_int(const char* key, int default_value);
+extern char* get_relay_private_key(void);
+
+// Throttling state
+static time_t last_report_time = 0;
+
+// Initialize monitoring system
+int init_monitoring_system(void) {
+    DEBUG_LOG("Monitoring system initialized");
+    last_report_time = 0;
+    return 0;
+}
+
+// Cleanup monitoring system
+void cleanup_monitoring_system(void) {
+    DEBUG_LOG("Monitoring system cleaned up");
+}
+
+// Check if monitoring is enabled
+int is_monitoring_enabled(void) {
+    return get_config_bool("kind_34567_reporting_enabled", 0);
+}
+
+// Get throttle interval
+int get_monitoring_throttle_seconds(void) {
+    return get_config_int("kind_34567_reporting_throttling_sec", 5);
+}
+
+// Enable/disable monitoring
+int set_monitoring_enabled(int enabled) {
+    // Update config table
+    const char* value = enabled ? "true" : "false";
+    
+    // This would call update_config_in_table() or similar
+    // For now, assume we have a function to update config
+    extern int update_config_in_table(const char* key, const char* value);
+    return update_config_in_table("kind_34567_reporting_enabled", value);
+}
+
+// Query event kind distribution from database
+static char* query_event_kind_distribution(void) {
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for monitoring query");
+        return NULL;
+    }
+    
+    struct timespec start_time;
+    clock_gettime(CLOCK_MONOTONIC, &start_time);
+    
+    // Query total events
+    sqlite3_stmt* stmt;
+    int total_events = 0;
+    
+    if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM events", -1, &stmt, NULL) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) {
+            total_events = sqlite3_column_int(stmt, 0);
+        }
+        sqlite3_finalize(stmt);
+    }
+    
+    // Query kind distribution
+    cJSON* response = cJSON_CreateObject();
+    cJSON_AddStringToObject(response, "data_type", "event_kinds");
+    cJSON_AddNumberToObject(response, "timestamp", (double)time(NULL));
+    
+    cJSON* data = cJSON_CreateObject();
+    cJSON_AddNumberToObject(data, "total_events", total_events);
+    
+    cJSON* distribution = cJSON_CreateArray();
+    
+    const char* sql = 
+        "SELECT kind, COUNT(*) as count, "
+        "ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM events), 2) as percentage "
+        "FROM events GROUP BY kind ORDER BY count DESC";
+    
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) == SQLITE_OK) {
+        while (sqlite3_step(stmt) == SQLITE_ROW) {
+            cJSON* kind_obj = cJSON_CreateObject();
+            cJSON_AddNumberToObject(kind_obj, "kind", sqlite3_column_int(stmt, 0));
+            cJSON_AddNumberToObject(kind_obj, "count", sqlite3_column_int64(stmt, 1));
+            cJSON_AddNumberToObject(kind_obj, "percentage", sqlite3_column_double(stmt, 2));
+            cJSON_AddItemToArray(distribution, kind_obj);
+        }
+        sqlite3_finalize(stmt);
+    }
+    
+    cJSON_AddItemToObject(data, "distribution", distribution);
+    cJSON_AddItemToObject(response, "data", data);
+    
+    // Calculate query time
+    struct timespec end_time;
+    clock_gettime(CLOCK_MONOTONIC, &end_time);
+    double query_time_ms = (end_time.tv_sec - start_time.tv_sec) * 1000.0 +
+                          (end_time.tv_nsec - start_time.tv_nsec) / 1000000.0;
+    
+    cJSON* metadata = cJSON_CreateObject();
+    cJSON_AddNumberToObject(metadata, "query_time_ms", query_time_ms);
+    cJSON_AddItemToObject(response, "metadata", metadata);
+    
+    char* json_string = cJSON_Print(response);
+    cJSON_Delete(response);
+    
+    return json_string;
+}
+
+// Generate and broadcast kind 34567 event
+static int generate_monitoring_event(const char* json_content) {
+    if (!json_content) return -1;
+    
+    // Get relay keys
+    const char* relay_pubkey = get_config_value("relay_pubkey");
+    char* relay_privkey_hex = get_relay_private_key();
+    if (!relay_pubkey || !relay_privkey_hex) {
+        if (relay_privkey_hex) free(relay_privkey_hex);
+        DEBUG_ERROR("Could not get relay keys for monitoring event");
+        return -1;
+    }
+    
+    // Convert relay private key to bytes
+    unsigned char relay_privkey[32];
+    if (nostr_hex_to_bytes(relay_privkey_hex, relay_privkey, sizeof(relay_privkey)) != 0) {
+        free(relay_privkey_hex);
+        DEBUG_ERROR("Failed to convert relay private key");
+        return -1;
+    }
+    free(relay_privkey_hex);
+    
+    // Create tags array
+    cJSON* tags = cJSON_CreateArray();
+    
+    // d tag for addressable event
+    cJSON* d_tag = cJSON_CreateArray();
+    cJSON_AddItemToArray(d_tag, cJSON_CreateString("d"));
+    cJSON_AddItemToArray(d_tag, cJSON_CreateString("event_kinds"));
+    cJSON_AddItemToArray(tags, d_tag);
+    
+    // relay tag
+    cJSON* relay_tag = cJSON_CreateArray();
+    cJSON_AddItemToArray(relay_tag, cJSON_CreateString("relay"));
+    cJSON_AddItemToArray(relay_tag, cJSON_CreateString(relay_pubkey));
+    cJSON_AddItemToArray(tags, relay_tag);
+    
+    // Create and sign event
+    cJSON* event = nostr_create_and_sign_event(
+        34567,              // kind
+        json_content,       // content
+        tags,               // tags
+        relay_privkey,      // private key
+        time(NULL)          // timestamp
+    );
+    
+    if (!event) {
+        DEBUG_ERROR("Failed to create and sign monitoring event");
+        return -1;
+    }
+    
+    // Broadcast to subscriptions
+    broadcast_event_to_subscriptions(event);
+    
+    // Store in database
+    int result = store_event(event);
+    
+    cJSON_Delete(event);
+    
+    return result;
+}
+
+// Called when an event is stored
+void monitoring_on_event_stored(void) {
+    // Check if monitoring is enabled
+    if (!is_monitoring_enabled()) {
+        return;
+    }
+    
+    // Check throttling
+    time_t now = time(NULL);
+    int throttle_seconds = get_monitoring_throttle_seconds();
+    
+    if (now - last_report_time < throttle_seconds) {
+        return;  // Too soon, skip this update
+    }
+    
+    // Query event kind distribution
+    char* json_content = query_event_kind_distribution();
+    if (!json_content) {
+        DEBUG_ERROR("Failed to query event kind distribution");
+        return;
+    }
+    
+    // Generate and broadcast monitoring event
+    int result = generate_monitoring_event(json_content);
+    free(json_content);
+    
+    if (result == 0) {
+        last_report_time = now;
+        DEBUG_LOG("Generated kind 34567 monitoring event");
+    } else {
+        DEBUG_ERROR("Failed to generate monitoring event");
+    }
+}
+```
+
+### 3. Integration: Modify `src/main.c`
+
+Add monitoring hook to event storage:
+
+```c
+// At top of file
+#include "monitoring.h"
+
+// In main() function, after init_database()
+if (init_monitoring_system() != 0) {
+    DEBUG_WARN("Failed to initialize monitoring system");
+    // Continue anyway - monitoring is optional
+}
+
+// In store_event() function, after successful storage
+int store_event(cJSON* event) {
+    // ... existing code ...
+    
+    if (rc != SQLITE_DONE) {
+        // ... error handling ...
+    }
+    
+    free(tags_json);
+    
+    // Trigger monitoring update
+    monitoring_on_event_stored();
+    
+    return 0;
+}
+
+// In cleanup section of main()
+cleanup_monitoring_system();
+```
+
+### 4. Admin API: Enable/Disable Monitoring
+
+Add admin command to enable monitoring (in `src/dm_admin.c` or `src/api.c`):
+
+```c
+// Handle admin command to enable monitoring
+if (strcmp(command, "enable_monitoring") == 0) {
+    set_monitoring_enabled(1);
+    send_nip17_response(sender_pubkey, 
+        "✅ Kind 34567 monitoring enabled", 
+        error_msg, sizeof(error_msg));
+    return 0;
+}
+
+// Handle admin command to disable monitoring
+if (strcmp(command, "disable_monitoring") == 0) {
+    set_monitoring_enabled(0);
+    send_nip17_response(sender_pubkey, 
+        "🔴 Kind 34567 monitoring disabled", 
+        error_msg, sizeof(error_msg));
+    return 0;
+}
+
+// Handle admin command to set throttle interval
+if (strncmp(command, "set_monitoring_throttle ", 24) == 0) {
+    int seconds = atoi(command + 24);
+    if (seconds >= 1 && seconds <= 3600) {
+        char value[16];
+        snprintf(value, sizeof(value), "%d", seconds);
+        update_config_in_table("kind_34567_reporting_throttling_sec", value);
+        
+        char response[128];
+        snprintf(response, sizeof(response), 
+            "✅ Monitoring throttle set to %d seconds", seconds);
+        send_nip17_response(sender_pubkey, response, error_msg, sizeof(error_msg));
+    }
+    return 0;
+}
+```
+
+---
+
+## Frontend Integration
+
+### Admin Dashboard Subscription
+
+```javascript
+// When admin logs in to dashboard
+async function enableMonitoring() {
+  // Send admin command to enable monitoring
+  await sendAdminCommand(['enable_monitoring']);
+  
+  // Subscribe to kind 34567 events
+  const subscription = {
+    kinds: [34567],
+    authors: [relayPubkey],
+    "#d": ["event_kinds"]
+  };
+  
+  relay.subscribe([subscription], {
+    onevent: (event) => {
+      handleMonitoringEvent(event);
+    }
+  });
+}
+
+// Handle incoming monitoring events
+function handleMonitoringEvent(event) {
+  const content = JSON.parse(event.content);
+  
+  if (content.data_type === 'event_kinds') {
+    updateEventKindsChart(content.data);
+    updateTotalEventsDisplay(content.data.total_events);
+  }
+}
+
+// When admin logs out or closes dashboard
+async function disableMonitoring() {
+  await sendAdminCommand(['disable_monitoring']);
+}
+```
+
+### Display Event Kind Distribution
+
+```javascript
+function updateEventKindsChart(data) {
+  const { total_events, distribution } = data;
+  
+  // Update total events display
+  document.getElementById('total-events').textContent = 
+    total_events.toLocaleString();
+  
+  // Update chart/table with distribution
+  const tableBody = document.getElementById('kind-distribution-table');
+  tableBody.innerHTML = '';
+  
+  distribution.forEach(item => {
+    const row = document.createElement('tr');
+    row.innerHTML = `
+      <td>Kind ${item.kind}</td>
+      <td>${item.count.toLocaleString()}</td>
+      <td>${item.percentage}%</td>
+    `;
+    tableBody.appendChild(row);
+  });
+}
+```
+
+---
+
+## Configuration Migration
+
+### Add to Schema or Migration Script
+
+```sql
+-- Add monitoring configuration
+INSERT INTO config (key, value, data_type, description, category) VALUES
+  ('kind_34567_reporting_enabled', 'false', 'boolean', 
+   'Enable/disable kind 34567 event kind distribution reporting', 'monitoring'),
+  ('kind_34567_reporting_throttling_sec', '5', 'integer', 
+   'Minimum seconds between kind 34567 reports (throttling)', 'monitoring');
+```
+
+Or add to existing config initialization in `src/config.c`.
+
+---
+
+## Testing
+
+### 1. Enable Monitoring
+
+```bash
+# Via admin command (NIP-17 DM)
+echo '["enable_monitoring"]' | nak event --kind 14 --content - ws://localhost:8888
+```
+
+### 2. Subscribe to Monitoring Events
+
+```bash
+# Subscribe to kind 34567 events
+nak req --kinds 34567 --authors <relay_pubkey> ws://localhost:8888
+```
+
+### 3. Generate Events
+
+```bash
+# Send some test events to trigger monitoring
+for i in {1..10}; do
+  nak event -c "Test event $i" ws://localhost:8888
+  sleep 1
+done
+```
+
+### 4. Verify Monitoring Events
+
+You should see kind 34567 events every 5 seconds (or configured throttle interval) with event kind distribution.
+
+---
+
+## Performance Impact
+
+### With 3 events/second (relay.damus.io scale)
+
+**Query execution**:
+- Frequency: Every 5 seconds (throttled)
+- Query time: ~700ms (for 1M events)
+- Overhead: 700ms / 5000ms = 14% (acceptable)
+
+**Per-event overhead**:
+- Check if enabled: < 0.01ms
+- Check throttle: < 0.01ms
+- Total: < 0.02ms per event (negligible)
+
+**Overall impact**: < 1% on event processing, 14% on query thread (separate from event processing)
+
+---
+
+## Future Enhancements
+
+Once this is working, easy to add:
+
+1. **More data types**: Add `d=connections`, `d=subscriptions`, etc.
+2. **Materialized counters**: Optimize queries for very large databases
+3. **Historical data**: Store monitoring events for trending
+4. **Alerts**: Trigger on thresholds (e.g., > 90% capacity)
+
+---
+
+## Summary
+
+This simplified plan provides:
+
+✅ **Single data type**: Event kind distribution (includes total events)  
+✅ **Two config variables**: Enable/disable and throttle control  
+✅ **On-demand activation**: Enabled when admin logs in  
+✅ **Simple throttling**: Prevents performance impact  
+✅ **Clean implementation**: ~200 lines of code  
+✅ **Easy to extend**: Add more data types later  
+
+**Estimated implementation time**: 4-6 hours
+
+**Files to create/modify**:
+- Create: `src/monitoring.h` (~30 lines)
+- Create: `src/monitoring.c` (~200 lines)
+- Modify: `src/main.c` (~10 lines)
+- Modify: `src/config.c` or migration (~5 lines)
+- Modify: `src/dm_admin.c` or `src/api.c` (~30 lines)
+- Create: `api/monitoring.js` (frontend, ~100 lines)
+
+**Total new code**: ~375 lines
--- a/docs/realtime_monitoring_design.md
+++ b/docs/realtime_monitoring_design.md
--- a/docs/relay_traffic_measurement.md
+++ b/docs/relay_traffic_measurement.md
@@ -0,0 +1,325 @@
+# Relay Traffic Measurement Guide
+
+## Measuring Real-World Relay Traffic
+
+To validate our performance assumptions, here are commands to measure actual event rates from live relays.
+
+---
+
+## Command: Count Events Over 1 Minute
+
+### Basic Command
+
+```bash
+# Count events from relay.damus.io over 60 seconds
+timeout 60 nak req -s $(date +%s) --stream wss://relay.damus.io | wc -l
+```
+
+This will:
+1. Subscribe to all new events (`-s $(date +%s)` = since now)
+2. Stream for 60 seconds (`timeout 60`)
+3. Count the lines (each line = 1 event)
+
+### With Event Rate Display
+
+```bash
+# Show events per second in real-time
+timeout 60 nak req -s $(date +%s) --stream wss://relay.damus.io | \
+  pv -l -i 1 -r > /dev/null
+```
+
+This displays:
+- Total events received
+- Current rate (events/second)
+- Average rate
+
+### With Detailed Statistics
+
+```bash
+# Count events and calculate statistics
+echo "Measuring relay traffic for 60 seconds..."
+START=$(date +%s)
+COUNT=$(timeout 60 nak req -s $START --stream wss://relay.damus.io | wc -l)
+END=$(date +%s)
+DURATION=$((END - START))
+
+echo "Results:"
+echo "  Total events: $COUNT"
+echo "  Duration: ${DURATION}s"
+echo "  Events/second: $(echo "scale=2; $COUNT / $DURATION" | bc)"
+echo "  Events/minute: $COUNT"
+```
+
+### With Event Kind Distribution
+
+```bash
+# Count events by kind over 60 seconds
+timeout 60 nak req -s $(date +%s) --stream wss://relay.damus.io | \
+  jq -r '.kind' | \
+  sort | uniq -c | sort -rn
+```
+
+Output example:
+```
+    45 1      # 45 text notes
+    12 3      # 12 contact lists
+     8 7      # 8 reactions
+     3 6      # 3 reposts
+```
+
+### With Timestamp Analysis
+
+```bash
+# Show event timestamps and calculate intervals
+timeout 60 nak req -s $(date +%s) --stream wss://relay.damus.io | \
+  jq -r '.created_at' | \
+  awk 'NR>1 {print $1-prev} {prev=$1}' | \
+  awk '{sum+=$1; count++} END {
+    print "Average interval:", sum/count, "seconds"
+    print "Events per second:", count/sum
+  }'
+```
+
+---
+
+## Testing Multiple Relays
+
+### Compare Traffic Across Relays
+
+```bash
+#!/bin/bash
+# test_relay_traffic.sh
+
+RELAYS=(
+  "wss://relay.damus.io"
+  "wss://nos.lol"
+  "wss://relay.nostr.band"
+  "wss://nostr.wine"
+)
+
+DURATION=60
+
+echo "Measuring relay traffic for ${DURATION} seconds..."
+echo ""
+
+for relay in "${RELAYS[@]}"; do
+  echo "Testing: $relay"
+  count=$(timeout $DURATION nak req -s $(date +%s) --stream "$relay" 2>/dev/null | wc -l)
+  rate=$(echo "scale=2; $count / $DURATION" | bc)
+  echo "  Events: $count"
+  echo "  Rate: ${rate}/sec"
+  echo ""
+done
+```
+
+---
+
+## Expected Results (Based on Real Measurements)
+
+### relay.damus.io (Large Public Relay)
+- **Expected rate**: 0.5-2 events/second
+- **60-second count**: 30-120 events
+- **Peak times**: Higher during US daytime hours
+
+### nos.lol (Medium Public Relay)
+- **Expected rate**: 0.2-0.8 events/second
+- **60-second count**: 12-48 events
+
+### Personal/Small Relays
+- **Expected rate**: 0.01-0.1 events/second
+- **60-second count**: 1-6 events
+
+---
+
+## Using Results to Validate Performance Assumptions
+
+After measuring your relay's traffic:
+
+1. **Calculate average events/second**:
+   ```
+   events_per_second = total_events / 60
+   ```
+
+2. **Estimate query overhead**:
+   ```
+   # For 100k event database:
+   query_time = 70ms
+   overhead_percentage = (query_time * events_per_second) / 1000 * 100
+   
+   # Example: 0.5 events/sec
+   overhead = (70 * 0.5) / 1000 * 100 = 3.5%
+   ```
+
+3. **Determine if optimization needed**:
+   - < 5% overhead: No optimization needed
+   - 5-20% overhead: Consider 1-second throttling
+   - > 20% overhead: Use materialized counters
+
+---
+
+## Real-Time Monitoring During Development
+
+### Monitor Your Own Relay
+
+```bash
+# Watch events in real-time with count
+nak req -s $(date +%s) --stream ws://localhost:8888 | \
+  awk '{count++; print count, $0}'
+```
+
+### Monitor with Event Details
+
+```bash
+# Show event kind and pubkey for each event
+nak req -s $(date +%s) --stream ws://localhost:8888 | \
+  jq -r '"[\(.kind)] \(.pubkey[0:8])... \(.content[0:50])"'
+```
+
+### Continuous Traffic Monitoring
+
+```bash
+# Monitor traffic in 10-second windows
+while true; do
+  echo "=== $(date) ==="
+  count=$(timeout 10 nak req -s $(date +%s) --stream ws://localhost:8888 | wc -l)
+  rate=$(echo "scale=2; $count / 10" | bc)
+  echo "Events: $count (${rate}/sec)"
+  sleep 1
+done
+```
+
+---
+
+## Performance Testing Commands
+
+### Simulate Load
+
+```bash
+# Send test events to measure query performance
+for i in {1..100}; do
+  nak event -c "Test event $i" ws://localhost:8888
+  sleep 0.1  # 10 events/second
+done
+```
+
+### Measure Query Response Time
+
+```bash
+# Time how long queries take with current database
+time sqlite3 your_relay.db "SELECT COUNT(*) FROM events"
+time sqlite3 your_relay.db "SELECT kind, COUNT(*) FROM events GROUP BY kind"
+```
+
+---
+
+## Automated Traffic Analysis Script
+
+Save this as `analyze_relay_traffic.sh`:
+
+```bash
+#!/bin/bash
+# Comprehensive relay traffic analysis
+
+RELAY="${1:-ws://localhost:8888}"
+DURATION="${2:-60}"
+
+echo "Analyzing relay: $RELAY"
+echo "Duration: ${DURATION} seconds"
+echo ""
+
+# Collect events
+TMPFILE=$(mktemp)
+timeout $DURATION nak req -s $(date +%s) --stream "$RELAY" > "$TMPFILE" 2>/dev/null
+
+# Calculate statistics
+TOTAL=$(wc -l < "$TMPFILE")
+RATE=$(echo "scale=2; $TOTAL / $DURATION" | bc)
+
+echo "=== Traffic Statistics ==="
+echo "Total events: $TOTAL"
+echo "Events/second: $RATE"
+echo "Events/minute: $(echo "$TOTAL * 60 / $DURATION" | bc)"
+echo ""
+
+echo "=== Event Kind Distribution ==="
+jq -r '.kind' "$TMPFILE" | sort | uniq -c | sort -rn | head -10
+echo ""
+
+echo "=== Top Publishers ==="
+jq -r '.pubkey[0:16]' "$TMPFILE" | sort | uniq -c | sort -rn | head -5
+echo ""
+
+echo "=== Performance Estimate ==="
+echo "For 100k event database:"
+echo "  Query time: ~70ms"
+echo "  Overhead: $(echo "scale=2; 70 * $RATE / 10" | bc)%"
+echo ""
+
+# Cleanup
+rm "$TMPFILE"
+```
+
+Usage:
+```bash
+chmod +x analyze_relay_traffic.sh
+./analyze_relay_traffic.sh wss://relay.damus.io 60
+```
+
+---
+
+## Interpreting Results
+
+### Low Traffic (< 0.1 events/sec)
+- **Typical for**: Personal relays, small communities
+- **Recommendation**: Trigger on every event, no optimization
+- **Expected overhead**: < 1%
+
+### Medium Traffic (0.1-0.5 events/sec)
+- **Typical for**: Medium public relays
+- **Recommendation**: Trigger on every event, consider throttling if database > 100k
+- **Expected overhead**: 1-5%
+
+### High Traffic (0.5-2 events/sec)
+- **Typical for**: Large public relays
+- **Recommendation**: Use 1-second throttling
+- **Expected overhead**: 5-20% without throttling, < 1% with throttling
+
+### Very High Traffic (> 2 events/sec)
+- **Typical for**: Major public relays (rare)
+- **Recommendation**: Use materialized counters
+- **Expected overhead**: > 20% without optimization
+
+---
+
+## Continuous Monitoring in Production
+
+### Add to Relay Startup
+
+```bash
+# In your relay startup script
+echo "Starting traffic monitoring..."
+nohup bash -c 'while true; do
+  count=$(timeout 60 nak req -s $(date +%s) --stream ws://localhost:8888 2>/dev/null | wc -l)
+  echo "$(date +%Y-%m-%d\ %H:%M:%S) - Events/min: $count" >> traffic.log
+done' &
+```
+
+### Analyze Historical Traffic
+
+```bash
+# View traffic trends
+cat traffic.log | awk '{print $4}' | \
+  awk '{sum+=$1; count++} END {print "Average:", sum/count, "events/min"}'
+```
+
+---
+
+## Conclusion
+
+Use these commands to:
+1. ✅ Measure real-world traffic on your relay
+2. ✅ Validate performance assumptions
+3. ✅ Determine if optimization is needed
+4. ✅ Monitor traffic trends over time
+
+**Remember**: Most relays will measure < 1 event/second, making the simple "trigger on every event" approach perfectly viable.
--- a/increment_and_push.sh
+++ b/increment_and_push.sh
@@ -121,10 +121,43 @@ increment_version() {
    print_status "Current version: $LATEST_TAG"
    print_status "New version: $NEW_VERSION"

+    # Update version in src/main.h
+    update_version_in_header "$NEW_VERSION" "$MAJOR" "${NEW_MINOR:-$MINOR}" "${NEW_PATCH:-$PATCH}"
+
    # Export for use in other functions
    export NEW_VERSION
 }

+# Function to update version macros in src/main.h
+update_version_in_header() {
+    local new_version="$1"
+    local major="$2"
+    local minor="$3"
+    local patch="$4"
+
+    print_status "Updating version in src/main.h..."
+
+    # Check if src/main.h exists
+    if [[ ! -f "src/main.h" ]]; then
+        print_error "src/main.h not found"
+        exit 1
+    fi
+
+    # Update VERSION macro
+    sed -i "s/#define VERSION \".*\"/#define VERSION \"$new_version\"/" src/main.h
+
+    # Update VERSION_MAJOR macro
+    sed -i "s/#define VERSION_MAJOR [0-9]\+/#define VERSION_MAJOR $major/" src/main.h
+
+    # Update VERSION_MINOR macro
+    sed -i "s/#define VERSION_MINOR .*/#define VERSION_MINOR $minor/" src/main.h
+
+    # Update VERSION_PATCH macro
+    sed -i "s/#define VERSION_PATCH [0-9]\+/#define VERSION_PATCH $patch/" src/main.h
+
+    print_success "Updated version in src/main.h to $new_version"
+}
+
 # Function to commit and push changes
 git_commit_and_push() {
    print_status "Preparing git commit..."
--- a/relay.pid
+++ b/relay.pid
@@ -1 +1 @@
-752613
+774065
--- a/src/api.c
+++ b/src/api.c
@@ -20,12 +20,502 @@
 #include "../nostr_core_lib/nostr_core/nostr_core.h"
 #include "../nostr_core_lib/nostr_core/nip017.h"
 #include "../nostr_core_lib/nostr_core/nip044.h"
+#include "subscriptions.h"
+
+// External subscription manager (from main.c via subscriptions.c)
+extern subscription_manager_t g_subscription_manager;

 // Global variables for config change system
 static pending_config_change_t* pending_changes_head = NULL;
 static int pending_changes_count = 0;
 #define CONFIG_CHANGE_TIMEOUT 300  // 5 minutes

+// Forward declarations for database functions
+int store_event(cJSON* event);
+int broadcast_event_to_subscriptions(cJSON* event);
+
+// Forward declarations for config functions
+char* get_relay_private_key(void);
+const char* get_config_value(const char* key);
+int get_config_bool(const char* key, int default_value);
+int update_config_in_table(const char* key, const char* value);
+
+// Monitoring system state (throttling now handled per-function)
+
+// Forward declaration for monitoring helper function
+int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_func)(void));
+
+// Monitoring system helper functions
+int get_monitoring_throttle_seconds(void) {
+    return get_config_int("kind_24567_reporting_throttle_sec", 5);
+}
+
+// Query event kind distribution from database
+cJSON* query_event_kind_distribution(void) {
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for monitoring query");
+        return NULL;
+    }
+
+    // Query event kinds distribution with total count
+    sqlite3_stmt* stmt;
+    const char* sql = "SELECT kind, COUNT(*) as count FROM events GROUP BY kind ORDER BY count DESC";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare event kind distribution query");
+        return NULL;
+    }
+
+    cJSON* distribution = cJSON_CreateObject();
+    cJSON_AddStringToObject(distribution, "data_type", "event_kinds");
+    cJSON_AddNumberToObject(distribution, "timestamp", (double)time(NULL));
+
+    cJSON* kinds_array = cJSON_CreateArray();
+    long long total_events = 0;
+
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        int kind = sqlite3_column_int(stmt, 0);
+        long long count = sqlite3_column_int64(stmt, 1);
+        total_events += count;
+
+        cJSON* kind_obj = cJSON_CreateObject();
+        cJSON_AddNumberToObject(kind_obj, "kind", kind);
+        cJSON_AddNumberToObject(kind_obj, "count", count);
+        cJSON_AddItemToArray(kinds_array, kind_obj);
+    }
+
+    sqlite3_finalize(stmt);
+
+    cJSON_AddNumberToObject(distribution, "total_events", total_events);
+    cJSON_AddItemToObject(distribution, "kinds", kinds_array);
+
+    return distribution;
+}
+
+// Query time-based statistics from database
+cJSON* query_time_based_statistics(void) {
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for time stats query");
+        return NULL;
+    }
+
+    time_t now = time(NULL);
+    cJSON* time_stats = cJSON_CreateObject();
+    cJSON_AddStringToObject(time_stats, "data_type", "time_stats");
+    cJSON_AddNumberToObject(time_stats, "timestamp", (double)now);
+
+    cJSON* periods_array = cJSON_CreateArray();
+
+    // Define time periods: 24h, 7d, 30d
+    struct {
+        const char* period;
+        time_t seconds;
+        const char* description;
+    } periods[] = {
+        {"last_24h", 86400, "Events in the last 24 hours"},
+        {"last_7d", 604800, "Events in the last 7 days"},
+        {"last_30d", 2592000, "Events in the last 30 days"},
+        {NULL, 0, NULL}
+    };
+
+    // Get total events count
+    sqlite3_stmt* total_stmt;
+    const char* total_sql = "SELECT COUNT(*) FROM events";
+    long long total_events = 0;
+
+    if (sqlite3_prepare_v2(g_db, total_sql, -1, &total_stmt, NULL) == SQLITE_OK) {
+        if (sqlite3_step(total_stmt) == SQLITE_ROW) {
+            total_events = sqlite3_column_int64(total_stmt, 0);
+        }
+        sqlite3_finalize(total_stmt);
+    }
+
+    // Query each time period
+    for (int i = 0; periods[i].period != NULL; i++) {
+        sqlite3_stmt* stmt;
+        const char* sql = "SELECT COUNT(*) FROM events WHERE created_at >= ?";
+
+        if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+            DEBUG_ERROR("Failed to prepare time stats query");
+            continue;
+        }
+
+        time_t cutoff = now - periods[i].seconds;
+        sqlite3_bind_int64(stmt, 1, cutoff);
+
+        long long count = 0;
+        if (sqlite3_step(stmt) == SQLITE_ROW) {
+            count = sqlite3_column_int64(stmt, 0);
+        }
+
+        sqlite3_finalize(stmt);
+
+        cJSON* period_obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(period_obj, "period", periods[i].period);
+        cJSON_AddNumberToObject(period_obj, "count", count);
+        cJSON_AddStringToObject(period_obj, "description", periods[i].description);
+        cJSON_AddItemToArray(periods_array, period_obj);
+    }
+
+    cJSON_AddItemToObject(time_stats, "periods", periods_array);
+    cJSON_AddNumberToObject(time_stats, "total_events", total_events);
+
+    return time_stats;
+}
+
+// Query top pubkeys by event count from database
+cJSON* query_top_pubkeys(void) {
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for top pubkeys query");
+        return NULL;
+    }
+
+    // Query top 10 pubkeys by event count
+    sqlite3_stmt* stmt;
+    const char* sql = "SELECT pubkey, COUNT(*) as count FROM events GROUP BY pubkey ORDER BY count DESC LIMIT 10";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare top pubkeys query");
+        return NULL;
+    }
+
+    cJSON* top_pubkeys = cJSON_CreateObject();
+    cJSON_AddStringToObject(top_pubkeys, "data_type", "top_pubkeys");
+    cJSON_AddNumberToObject(top_pubkeys, "timestamp", (double)time(NULL));
+
+    cJSON* pubkeys_array = cJSON_CreateArray();
+
+    // Get total events count for percentage calculation
+    sqlite3_stmt* total_stmt;
+    const char* total_sql = "SELECT COUNT(*) FROM events";
+    long long total_events = 0;
+
+    if (sqlite3_prepare_v2(g_db, total_sql, -1, &total_stmt, NULL) == SQLITE_OK) {
+        if (sqlite3_step(total_stmt) == SQLITE_ROW) {
+            total_events = sqlite3_column_int64(total_stmt, 0);
+        }
+        sqlite3_finalize(total_stmt);
+    }
+
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        const char* pubkey = (const char*)sqlite3_column_text(stmt, 0);
+        long long count = sqlite3_column_int64(stmt, 1);
+
+        cJSON* pubkey_obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(pubkey_obj, "pubkey", pubkey ? pubkey : "");
+        cJSON_AddNumberToObject(pubkey_obj, "event_count", count);
+        // Percentage will be calculated by frontend using total_events
+        cJSON_AddItemToArray(pubkeys_array, pubkey_obj);
+    }
+
+    sqlite3_finalize(stmt);
+
+    cJSON_AddItemToObject(top_pubkeys, "pubkeys", pubkeys_array);
+    cJSON_AddNumberToObject(top_pubkeys, "total_events", total_events);
+
+    return top_pubkeys;
+}
+
+// Query active subscriptions summary from database
+cJSON* query_active_subscriptions(void) {
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for active subscriptions query");
+        return NULL;
+    }
+
+    // Get configuration limits
+    int max_subs = g_subscription_manager.max_total_subscriptions;
+    int max_per_client = g_subscription_manager.max_subscriptions_per_client;
+
+    // Query total active subscriptions from database
+    sqlite3_stmt* stmt;
+    const char* sql =
+        "SELECT COUNT(*) as total_subs, "
+        "COUNT(DISTINCT client_ip) as client_count "
+        "FROM subscription_events "
+        "WHERE event_type = 'created' AND ended_at IS NULL";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare active subscriptions query");
+        return NULL;
+    }
+
+    int total_subs = 0;
+    int client_count = 0;
+
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        total_subs = sqlite3_column_int(stmt, 0);
+        client_count = sqlite3_column_int(stmt, 1);
+    }
+    sqlite3_finalize(stmt);
+
+    // Query max subscriptions per client
+    int most_subs_per_client = 0;
+    const char* max_sql =
+        "SELECT MAX(sub_count) FROM ("
+        "  SELECT COUNT(*) as sub_count "
+        "  FROM subscription_events "
+        "  WHERE event_type = 'created' AND ended_at IS NULL "
+        "  GROUP BY client_ip"
+        ")";
+
+    if (sqlite3_prepare_v2(g_db, max_sql, -1, &stmt, NULL) == SQLITE_OK) {
+        if (sqlite3_step(stmt) == SQLITE_ROW) {
+            most_subs_per_client = sqlite3_column_int(stmt, 0);
+        }
+        sqlite3_finalize(stmt);
+    }
+
+    // Calculate statistics
+    double utilization_percentage = max_subs > 0 ? (total_subs * 100.0 / max_subs) : 0.0;
+    double avg_subs_per_client = client_count > 0 ? (total_subs * 1.0 / client_count) : 0.0;
+
+    // Build JSON response matching the design spec
+    cJSON* subscriptions = cJSON_CreateObject();
+    cJSON_AddStringToObject(subscriptions, "data_type", "active_subscriptions");
+    cJSON_AddNumberToObject(subscriptions, "timestamp", (double)time(NULL));
+
+    cJSON* data = cJSON_CreateObject();
+    cJSON_AddNumberToObject(data, "total_subscriptions", total_subs);
+    cJSON_AddNumberToObject(data, "max_subscriptions", max_subs);
+    cJSON_AddNumberToObject(data, "utilization_percentage", utilization_percentage);
+    cJSON_AddNumberToObject(data, "subscriptions_per_client_avg", avg_subs_per_client);
+    cJSON_AddNumberToObject(data, "most_subscriptions_per_client", most_subs_per_client);
+    cJSON_AddNumberToObject(data, "max_subscriptions_per_client", max_per_client);
+    cJSON_AddNumberToObject(data, "active_clients", client_count);
+
+    cJSON_AddItemToObject(subscriptions, "data", data);
+
+    return subscriptions;
+}
+
+// Query detailed subscription information from database log (ADMIN ONLY)
+// Uses subscription_events table instead of in-memory iteration to avoid mutex contention
+cJSON* query_subscription_details(void) {
+    extern sqlite3* g_db;
+    if (!g_db) {
+        DEBUG_ERROR("Database not available for subscription details query");
+        return NULL;
+    }
+
+    // Query active subscriptions directly from subscription_events table
+    // Get subscriptions that were created but not yet closed/expired/disconnected
+    sqlite3_stmt* stmt;
+    const char* sql =
+        "SELECT subscription_id, client_ip, filter_json, events_sent, "
+        "created_at, (strftime('%s', 'now') - created_at) as duration_seconds "
+        "FROM subscription_events "
+        "WHERE event_type = 'created' AND ended_at IS NULL "
+        "ORDER BY created_at DESC LIMIT 100";
+
+    if (sqlite3_prepare_v2(g_db, sql, -1, &stmt, NULL) != SQLITE_OK) {
+        DEBUG_ERROR("Failed to prepare subscription details query");
+        return NULL;
+    }
+
+    time_t current_time = time(NULL);
+    cJSON* subscriptions_data = cJSON_CreateObject();
+    cJSON_AddStringToObject(subscriptions_data, "data_type", "subscription_details");
+    cJSON_AddNumberToObject(subscriptions_data, "timestamp", (double)current_time);
+
+    cJSON* data = cJSON_CreateObject();
+    cJSON* subscriptions_array = cJSON_CreateArray();
+
+    // Iterate through query results
+    while (sqlite3_step(stmt) == SQLITE_ROW) {
+        cJSON* sub_obj = cJSON_CreateObject();
+
+        // Extract subscription data from database
+        const char* sub_id = (const char*)sqlite3_column_text(stmt, 0);
+        const char* client_ip = (const char*)sqlite3_column_text(stmt, 1);
+        const char* filter_json = (const char*)sqlite3_column_text(stmt, 2);
+        long long events_sent = sqlite3_column_int64(stmt, 3);
+        long long created_at = sqlite3_column_int64(stmt, 4);
+        long long duration_seconds = sqlite3_column_int64(stmt, 5);
+
+        // Add basic subscription info
+        cJSON_AddStringToObject(sub_obj, "id", sub_id ? sub_id : "");
+        cJSON_AddStringToObject(sub_obj, "client_ip", client_ip ? client_ip : "");
+        cJSON_AddNumberToObject(sub_obj, "created_at", (double)created_at);
+        cJSON_AddNumberToObject(sub_obj, "duration_seconds", (double)duration_seconds);
+        cJSON_AddNumberToObject(sub_obj, "events_sent", events_sent);
+        cJSON_AddBoolToObject(sub_obj, "active", 1);  // All from this view are active
+
+        // Parse and add filter JSON if available
+        if (filter_json) {
+            cJSON* filters = cJSON_Parse(filter_json);
+            if (filters) {
+                cJSON_AddItemToObject(sub_obj, "filters", filters);
+            } else {
+                // If parsing fails, add empty array
+                cJSON_AddItemToObject(sub_obj, "filters", cJSON_CreateArray());
+            }
+        } else {
+            cJSON_AddItemToObject(sub_obj, "filters", cJSON_CreateArray());
+        }
+
+        cJSON_AddItemToArray(subscriptions_array, sub_obj);
+    }
+
+    sqlite3_finalize(stmt);
+
+    // Add subscriptions array and count to data
+    cJSON_AddItemToObject(data, "subscriptions", subscriptions_array);
+    cJSON_AddNumberToObject(data, "total_count", cJSON_GetArraySize(subscriptions_array));
+
+    cJSON_AddItemToObject(subscriptions_data, "data", data);
+
+    return subscriptions_data;
+}
+
+// Generate and broadcast monitoring event
+int generate_monitoring_event(void) {
+    // Generate event_kinds monitoring event
+    if (generate_monitoring_event_for_type("event_kinds", query_event_kind_distribution) != 0) {
+        DEBUG_ERROR("Failed to generate event_kinds monitoring event");
+        return -1;
+    }
+
+    // Generate time_stats monitoring event
+    if (generate_monitoring_event_for_type("time_stats", query_time_based_statistics) != 0) {
+        DEBUG_ERROR("Failed to generate time_stats monitoring event");
+        return -1;
+    }
+
+    // Generate top_pubkeys monitoring event
+    if (generate_monitoring_event_for_type("top_pubkeys", query_top_pubkeys) != 0) {
+        DEBUG_ERROR("Failed to generate top_pubkeys monitoring event");
+        return -1;
+    }
+
+    // Generate active_subscriptions monitoring event
+    if (generate_monitoring_event_for_type("active_subscriptions", query_active_subscriptions) != 0) {
+        DEBUG_ERROR("Failed to generate active_subscriptions monitoring event");
+        return -1;
+    }
+
+    // Generate subscription_details monitoring event (admin-only)
+    if (generate_monitoring_event_for_type("subscription_details", query_subscription_details) != 0) {
+        DEBUG_ERROR("Failed to generate subscription_details monitoring event");
+        return -1;
+    }
+
+    DEBUG_INFO("Generated and broadcast all monitoring events");
+    return 0;
+}
+
+// Helper function to generate monitoring event for a specific type
+int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_func)(void)) {
+    // Query the monitoring data
+    cJSON* monitoring_data = query_func();
+    if (!monitoring_data) {
+        DEBUG_ERROR("Failed to query monitoring data for %s", d_tag_value);
+        return -1;
+    }
+
+    // Convert to JSON string for content
+    char* content_json = cJSON_Print(monitoring_data);
+    cJSON_Delete(monitoring_data);
+
+    if (!content_json) {
+        DEBUG_ERROR("Failed to serialize monitoring data for %s", d_tag_value);
+        return -1;
+    }
+
+    // Get relay keys for signing
+    const char* relay_pubkey = get_config_value("relay_pubkey");
+    char* relay_privkey_hex = get_relay_private_key();
+    if (!relay_pubkey || !relay_privkey_hex) {
+        free(content_json);
+        DEBUG_ERROR("Could not get relay keys for monitoring event (%s)", d_tag_value);
+        return -1;
+    }
+
+    // Convert relay private key to bytes
+    unsigned char relay_privkey[32];
+    if (nostr_hex_to_bytes(relay_privkey_hex, relay_privkey, sizeof(relay_privkey)) != 0) {
+        free(relay_privkey_hex);
+        free(content_json);
+        DEBUG_ERROR("Failed to convert relay private key for monitoring event (%s)", d_tag_value);
+        return -1;
+    }
+    free(relay_privkey_hex);
+
+    // Create monitoring event (kind 24567 - ephemeral)
+    cJSON* monitoring_event = cJSON_CreateObject();
+    cJSON_AddStringToObject(monitoring_event, "id", ""); // Will be set by signing
+    cJSON_AddStringToObject(monitoring_event, "pubkey", relay_pubkey);
+    cJSON_AddNumberToObject(monitoring_event, "created_at", (double)time(NULL));
+    cJSON_AddNumberToObject(monitoring_event, "kind", 24567);
+    cJSON_AddStringToObject(monitoring_event, "content", content_json);
+
+    // Create tags array with d tag for identification
+    cJSON* tags = cJSON_CreateArray();
+
+    // d tag for event identification
+    cJSON* d_tag = cJSON_CreateArray();
+    cJSON_AddItemToArray(d_tag, cJSON_CreateString("d"));
+    cJSON_AddItemToArray(d_tag, cJSON_CreateString(d_tag_value));
+    cJSON_AddItemToArray(tags, d_tag);
+
+    cJSON_AddItemToObject(monitoring_event, "tags", tags);
+
+    // Use the library function to create and sign the event
+    cJSON* signed_event = nostr_create_and_sign_event(
+        24567,                              // kind (ephemeral)
+        cJSON_GetStringValue(cJSON_GetObjectItem(monitoring_event, "content")), // content
+        tags,                               // tags
+        relay_privkey,                      // private key
+        (time_t)cJSON_GetNumberValue(cJSON_GetObjectItem(monitoring_event, "created_at")) // timestamp
+    );
+
+    if (!signed_event) {
+        cJSON_Delete(monitoring_event);
+        free(content_json);
+        DEBUG_ERROR("Failed to create and sign monitoring event (%s)", d_tag_value);
+        return -1;
+    }
+
+    // Replace the unsigned event with the signed one
+    cJSON_Delete(monitoring_event);
+    monitoring_event = signed_event;
+
+    // Broadcast the ephemeral event to active subscriptions (no database storage)
+    broadcast_event_to_subscriptions(monitoring_event);
+
+    cJSON_Delete(monitoring_event);
+    free(content_json);
+
+    DEBUG_LOG("Monitoring event broadcast (ephemeral kind 24567, type: %s)", d_tag_value);
+    return 0;
+}
+
+// Monitoring hook called when an event is stored
+void monitoring_on_event_stored(void) {
+    // Check throttling first (cheapest check)
+    static time_t last_monitoring_time = 0;
+    time_t current_time = time(NULL);
+    int throttle_seconds = get_monitoring_throttle_seconds();
+    
+    if (current_time - last_monitoring_time < throttle_seconds) {
+        return;
+    }
+    
+    // Check if anyone is subscribed to monitoring events (kind 24567)
+    // This is the ONLY activation check needed - if someone subscribes, they want monitoring
+    if (!has_subscriptions_for_kind(24567)) {
+        return; // No subscribers = no expensive operations
+    }
+    
+    // Generate monitoring events only when someone is listening
+    last_monitoring_time = current_time;
+    generate_monitoring_event();
+}
+
 // Forward declaration for known_configs (defined in config.c)
 typedef struct {
    const char* key;
@@ -107,9 +597,10 @@ int broadcast_event_to_subscriptions(cJSON* event);
 char* get_relay_private_key(void);
 const char* get_config_value(const char* key);
 int get_config_bool(const char* key, int default_value);
+int update_config_in_table(const char* key, const char* value);

-// Forward declarations for database functions
-int store_event(cJSON* event);
+// Forward declaration for monitoring helper function
+int generate_monitoring_event_for_type(const char* d_tag_value, cJSON* (*query_func)(void));

 // Handle HTTP request for embedded files (assumes GET)
 int handle_embedded_file_request(struct lws* wsi, const char* requested_uri) {
@@ -636,6 +1127,12 @@ char* generate_stats_json(void) {
    }
    cJSON_AddNumberToObject(response, "database_size_bytes", db_size);

+    // Get active subscriptions count from in-memory manager
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+    int active_subs = g_subscription_manager.total_subscriptions;
+    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+    cJSON_AddNumberToObject(response, "active_subscriptions", active_subs);
+
    // Query total events count
    sqlite3_stmt* stmt;
    if (sqlite3_prepare_v2(g_db, "SELECT COUNT(*) FROM events", -1, &stmt, NULL) == SQLITE_OK) {
@@ -914,6 +1411,11 @@ char* generate_stats_text(void) {
        long long db_bytes = db_size ? (long long)cJSON_GetNumberValue(db_size) : 0;
        double db_mb = db_bytes / (1024.0 * 1024.0);

+        // Get active subscriptions count from in-memory manager
+        pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+        int active_subs = g_subscription_manager.total_subscriptions;
+        pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+
        // Format timestamps
        char oldest_str[64] = "-";
        char newest_str[64] = "-";
@@ -953,10 +1455,11 @@ char* generate_stats_text(void) {
            "Metric\tValue\tDescription\n"
            "Database Size\t%.2f MB (%lld bytes)\tCurrent database file size\n"
            "Total Events\t%lld\tTotal number of events stored\n"
+            "Active Subscriptions\t%d\tCurrent active WebSocket subscriptions\n"
            "Oldest Event\t%s\tTimestamp of oldest event\n"
            "Newest Event\t%s\tTimestamp of newest event\n"
            "\n",
-            db_mb, db_bytes, total, oldest_str, newest_str);
+            db_mb, db_bytes, total, active_subs, oldest_str, newest_str);

        // Event Kind Distribution section
        offset += snprintf(stats_text + offset, 16384 - offset,
@@ -1682,3 +2185,92 @@ int process_config_change_request(const char* admin_pubkey, const char* message)
    free(change_id);
    return 1; // Confirmation sent
 }
+
+// Handle monitoring system admin commands
+int handle_monitoring_command(cJSON* event, const char* command, char* error_message, size_t error_size, struct lws* wsi) {
+    if (!event || !command || !error_message) {
+        return -1;
+    }
+
+    // Get request event ID for response correlation
+    cJSON* request_id_obj = cJSON_GetObjectItem(event, "id");
+    if (!request_id_obj || !cJSON_IsString(request_id_obj)) {
+        snprintf(error_message, error_size, "Missing request event ID");
+        return -1;
+    }
+    const char* request_id = cJSON_GetStringValue(request_id_obj);
+
+    // Get sender pubkey for response
+    cJSON* sender_pubkey_obj = cJSON_GetObjectItem(event, "pubkey");
+    if (!sender_pubkey_obj || !cJSON_IsString(sender_pubkey_obj)) {
+        snprintf(error_message, error_size, "Missing sender pubkey");
+        return -1;
+    }
+    const char* sender_pubkey = cJSON_GetStringValue(sender_pubkey_obj);
+
+    // Parse command
+    char cmd[256];
+    char arg[256];
+    cmd[0] = '\0';
+    arg[0] = '\0';
+
+    // Simple command parsing - split on space
+    const char* space_pos = strchr(command, ' ');
+    if (space_pos) {
+        size_t cmd_len = space_pos - command;
+        if (cmd_len < sizeof(cmd)) {
+            memcpy(cmd, command, cmd_len);
+            cmd[cmd_len] = '\0';
+            strcpy(arg, space_pos + 1);
+        }
+    } else {
+        strcpy(cmd, command);
+    }
+
+    // Convert to lowercase for case-insensitive matching
+    for (char* p = cmd; *p; p++) {
+        if (*p >= 'A' && *p <= 'Z') *p = *p + 32;
+    }
+
+    // Handle set_monitoring_throttle command (only remaining monitoring command)
+    if (strcmp(cmd, "set_monitoring_throttle") == 0) {
+        if (arg[0] == '\0') {
+            char* response_content = "❌ Missing throttle value\n\nUsage: set_monitoring_throttle <seconds>";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        }
+
+        char* endptr;
+        long throttle_seconds = strtol(arg, &endptr, 10);
+        if (*endptr != '\0' || throttle_seconds < 1 || throttle_seconds > 3600) {
+            char* response_content = "❌ Invalid throttle value\n\nThrottle must be between 1 and 3600 seconds.";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        }
+
+        char throttle_str[16];
+        snprintf(throttle_str, sizeof(throttle_str), "%ld", throttle_seconds);
+
+        if (update_config_in_table("kind_24567_reporting_throttle_sec", throttle_str) == 0) {
+            char response_content[256];
+            snprintf(response_content, sizeof(response_content),
+                    "✅ Monitoring throttle updated\n\n"
+                    "Minimum interval between monitoring events: %ld seconds\n\n"
+                    "ℹ️ Monitoring activates automatically when you subscribe to kind 24567 events.",
+                    throttle_seconds);
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        } else {
+            char* response_content = "❌ Failed to update monitoring throttle";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        }
+    } else {
+        char response_content[512];
+        snprintf(response_content, sizeof(response_content),
+                "❌ Unknown monitoring command: %s\n\n"
+                "Available command:\n"
+                "• set_monitoring_throttle <seconds>\n\n"
+                "ℹ️ Monitoring is now subscription-based:\n"
+                "Subscribe to kind 24567 events to receive real-time monitoring data.\n"
+                "Monitoring automatically activates when subscriptions exist and deactivates when they close.",
+                cmd);
+        return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+    }
+}
--- a/src/api.h
+++ b/src/api.h
@@ -59,4 +59,8 @@ int validate_sql_query(const char* query, char* error_message, size_t error_size
 char* execute_sql_query(const char* query, const char* request_id, char* error_message, size_t error_size);
 int handle_sql_query_unified(cJSON* event, const char* query, char* error_message, size_t error_size, struct lws* wsi);

+// Monitoring system functions
+void monitoring_on_event_stored(void);
+int get_monitoring_throttle_seconds(void);
+
 #endif // API_H
--- a/src/config.c
+++ b/src/config.c
@@ -3,6 +3,19 @@
 #include "debug.h"
 #include "default_config_event.h"
 #include "dm_admin.h"
+
+// Undefine VERSION macros before including nostr_core.h to avoid redefinition warnings
+// This must come AFTER default_config_event.h so that RELAY_VERSION macro expansion works correctly
+#ifdef VERSION
+#undef VERSION
+#endif
+#ifdef VERSION_MINOR
+#undef VERSION_MINOR
+#endif
+#ifdef VERSION_PATCH
+#undef VERSION_PATCH
+#endif
+
 #include "../nostr_core_lib/nostr_core/nostr_core.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -4099,6 +4112,23 @@ int populate_all_config_values_atomic(const char* admin_pubkey, const char* rela
        return -1;
    }

+    // Insert monitoring system config entry (ephemeral kind 24567)
+    // Note: Monitoring is automatically activated when clients subscribe to kind 24567
+    sqlite3_reset(stmt);
+    sqlite3_bind_text(stmt, 1, "kind_24567_reporting_throttle_sec", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 2, "5", -1, SQLITE_STATIC);  // integer, default 5 seconds
+    sqlite3_bind_text(stmt, 3, "integer", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 4, "Minimum seconds between monitoring event reports (ephemeral kind 24567)", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 5, "monitoring", -1, SQLITE_STATIC);
+    sqlite3_bind_int(stmt, 6, 0);  // does not require restart
+    rc = sqlite3_step(stmt);
+    if (rc != SQLITE_DONE) {
+        DEBUG_ERROR("Failed to insert kind_24567_reporting_throttle_sec: %s", sqlite3_errmsg(g_db));
+        sqlite3_finalize(stmt);
+        sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
+        return -1;
+    }
+
    sqlite3_finalize(stmt);

    // Commit transaction
--- a/src/default_config_event.h
+++ b/src/default_config_event.h
@@ -72,7 +72,13 @@ static const struct {
    
    // Performance Settings
    {"default_limit", "500"},
-    {"max_limit", "5000"}
+    {"max_limit", "5000"},
+    
+    // Proxy Settings
+    // Trust proxy headers (X-Forwarded-For, X-Real-IP) for accurate client IP detection
+    // Safe for informational/debugging use. Only becomes a security concern if you implement
+    // IP-based rate limiting or access control (which would require firewall protection anyway)
+    {"trust_proxy_headers", "true"}
 };

 // Number of default configuration values
--- a/src/dm_admin.c
+++ b/src/dm_admin.c
@@ -1,3 +1,6 @@
+// Note to assistants. dm_admin is only for functions relating to direct messaging
+
+
 #define _GNU_SOURCE
 #include "config.h"
 #include "debug.h"
--- a/src/dm_admin.h
+++ b/src/dm_admin.h
@@ -1,3 +1,5 @@
+// Note to assistants. dm_admin is only for functions relating to direct messaging
+
 #ifndef DM_ADMIN_H
 #define DM_ADMIN_H

--- a/src/embedded_web_content.c
+++ b/src/embedded_web_content.c
--- a/src/main.c
+++ b/src/main.c
@@ -149,6 +149,9 @@ int mark_event_as_deleted(const char* event_id, const char* deletion_event_id, c
 // Forward declaration for database functions
 int store_event(cJSON* event);

+// Forward declaration for monitoring system
+void monitoring_on_event_stored(void);
+
 // Forward declarations for NIP-11 relay information handling
 void init_relay_info();
 void cleanup_relay_info();
@@ -729,8 +732,12 @@ int store_event(cJSON* event) {
        free(tags_json);
        return -1;
    }
-    
+
    free(tags_json);
+
+    // Call monitoring hook after successful event storage
+    monitoring_on_event_stored();
+
    return 0;
 }

@@ -1979,6 +1986,7 @@ int main(int argc, char* argv[]) {
    
    // Initialize NIP-40 expiration configuration
    init_expiration_config();
+
    // Update subscription manager configuration
    update_subscription_manager_config();

--- a/src/main.h
+++ b/src/main.h
@@ -10,10 +10,10 @@
 #define MAIN_H

 // Version information (auto-updated by build system)
-#define VERSION "v0.4.6"
+#define VERSION "v0.7.33"
 #define VERSION_MAJOR 0
-#define VERSION_MINOR 4
-#define VERSION_PATCH 6
+#define VERSION_MINOR 7
+#define VERSION_PATCH 33

 // Relay metadata (authoritative source for NIP-11 information)
 #define RELAY_NAME "C-Relay"
--- a/src/subscriptions.c
+++ b/src/subscriptions.c
@@ -664,6 +664,38 @@ int broadcast_event_to_subscriptions(cJSON* event) {
    return broadcasts;
 }

+// Check if any active subscription exists for a specific event kind (thread-safe)
+int has_subscriptions_for_kind(int event_kind) {
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+    
+    subscription_t* sub = g_subscription_manager.active_subscriptions;
+    while (sub) {
+        if (sub->active && sub->filters) {
+            subscription_filter_t* filter = sub->filters;
+            while (filter) {
+                // Check if this filter includes our event kind
+                if (filter->kinds && cJSON_IsArray(filter->kinds)) {
+                    cJSON* kind_item = NULL;
+                    cJSON_ArrayForEach(kind_item, filter->kinds) {
+                        if (cJSON_IsNumber(kind_item)) {
+                            int filter_kind = (int)cJSON_GetNumberValue(kind_item);
+                            if (filter_kind == event_kind) {
+                                pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+                                return 1; // Found matching subscription
+                            }
+                        }
+                    }
+                }
+                filter = filter->next;
+            }
+        }
+        sub = sub->next;
+    }
+    
+    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+    return 0; // No matching subscriptions
+}
+

 /////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////
--- a/src/subscriptions.h
+++ b/src/subscriptions.h
@@ -118,4 +118,7 @@ void log_subscription_disconnected(const char* client_ip);
 void log_event_broadcast(const char* event_id, const char* sub_id, const char* client_ip);
 void update_subscription_events_sent(const char* sub_id, int events_sent);

+// Subscription query functions
+int has_subscriptions_for_kind(int event_kind);
+
 #endif // SUBSCRIPTIONS_H
--- a/src/websockets.c
+++ b/src/websockets.c
@@ -247,7 +247,57 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso

            // Get real client IP address
            char client_ip[CLIENT_IP_MAX_LENGTH];
-            lws_get_peer_simple(wsi, client_ip, sizeof(client_ip));
+            memset(client_ip, 0, sizeof(client_ip));
+            
+            // Check if we should trust proxy headers
+            int trust_proxy = get_config_bool("trust_proxy_headers", 0);
+            
+            if (trust_proxy) {
+                // Try to get IP from X-Forwarded-For header first
+                char x_forwarded_for[CLIENT_IP_MAX_LENGTH];
+                int header_len = lws_hdr_copy(wsi, x_forwarded_for, sizeof(x_forwarded_for) - 1, WSI_TOKEN_X_FORWARDED_FOR);
+                
+                if (header_len > 0) {
+                    x_forwarded_for[header_len] = '\0';
+                    // X-Forwarded-For can contain multiple IPs (client, proxy1, proxy2, ...)
+                    // We want the first (leftmost) IP which is the original client
+                    char* comma = strchr(x_forwarded_for, ',');
+                    if (comma) {
+                        *comma = '\0'; // Truncate at first comma
+                    }
+                    // Trim leading/trailing whitespace
+                    char* ip_start = x_forwarded_for;
+                    while (*ip_start == ' ' || *ip_start == '\t') ip_start++;
+                    size_t ip_len = strlen(ip_start);
+                    while (ip_len > 0 && (ip_start[ip_len-1] == ' ' || ip_start[ip_len-1] == '\t')) {
+                        ip_start[--ip_len] = '\0';
+                    }
+                    if (ip_len > 0 && ip_len < CLIENT_IP_MAX_LENGTH) {
+                        strncpy(client_ip, ip_start, CLIENT_IP_MAX_LENGTH - 1);
+                        client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
+                        DEBUG_TRACE("Using X-Forwarded-For IP: %s", client_ip);
+                    }
+                }
+                
+                // If X-Forwarded-For didn't work, try X-Real-IP
+                if (client_ip[0] == '\0') {
+                    char x_real_ip[CLIENT_IP_MAX_LENGTH];
+                    header_len = lws_hdr_copy(wsi, x_real_ip, sizeof(x_real_ip) - 1, WSI_TOKEN_HTTP_X_REAL_IP);
+                    
+                    if (header_len > 0) {
+                        x_real_ip[header_len] = '\0';
+                        strncpy(client_ip, x_real_ip, CLIENT_IP_MAX_LENGTH - 1);
+                        client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
+                        DEBUG_TRACE("Using X-Real-IP: %s", client_ip);
+                    }
+                }
+            }
+            
+            // Fall back to direct connection IP if proxy headers not available or not trusted
+            if (client_ip[0] == '\0') {
+                lws_get_peer_simple(wsi, client_ip, sizeof(client_ip));
+                DEBUG_TRACE("Using direct connection IP: %s", client_ip);
+            }

            // Ensure client_ip is null-terminated and copy safely
            client_ip[CLIENT_IP_MAX_LENGTH - 1] = '\0';
@@ -256,6 +306,9 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
            memcpy(pss->client_ip, client_ip, copy_len);
            pss->client_ip[copy_len] = '\0';

+            // Record connection establishment time for duration tracking
+            pss->connection_established = time(NULL);
+
            DEBUG_LOG("WebSocket connection established from %s", pss->client_ip);

            // Initialize NIP-42 authentication state
@@ -625,16 +678,24 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
                                                    }
                                                }
                                            } else {
-                                                DEBUG_TRACE("Storing regular event in database");
-                                                // Regular event - store in database and broadcast
-                                                if (store_event(event) != 0) {
-                                                    DEBUG_ERROR("Failed to store event in database");
-                                                    result = -1;
-                                                    strncpy(error_message, "error: failed to store event", sizeof(error_message) - 1);
-                                                } else {
-                                                    DEBUG_LOG("Event stored and broadcast (kind %d)", event_kind);
-                                                    // Broadcast event to matching persistent subscriptions
+                                                // Check if this is an ephemeral event (kinds 20000-29999)
+                                                // Per NIP-01: ephemeral events are broadcast but never stored
+                                                if (event_kind >= 20000 && event_kind < 30000) {
+                                                    DEBUG_TRACE("Ephemeral event (kind %d) - broadcasting without storage", event_kind);
+                                                    // Broadcast directly to subscriptions without database storage
                                                    broadcast_event_to_subscriptions(event);
+                                                } else {
+                                                    DEBUG_TRACE("Storing regular event in database");
+                                                    // Regular event - store in database and broadcast
+                                                    if (store_event(event) != 0) {
+                                                        DEBUG_ERROR("Failed to store event in database");
+                                                        result = -1;
+                                                        strncpy(error_message, "error: failed to store event", sizeof(error_message) - 1);
+                                                    } else {
+                                                        DEBUG_LOG("Event stored and broadcast (kind %d)", event_kind);
+                                                        // Broadcast event to matching persistent subscriptions
+                                                        broadcast_event_to_subscriptions(event);
+                                                    }
                                                }
                                            }
                                        } else {
@@ -913,10 +974,38 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso
            
        case LWS_CALLBACK_CLOSED:
            DEBUG_TRACE("WebSocket connection closed");
-            DEBUG_LOG("WebSocket connection closed from %s", pss ? pss->client_ip : "unknown");
-
-            // Clean up session subscriptions
+            
+            // Enhanced closure logging with detailed diagnostics
            if (pss) {
+                // Calculate connection duration
+                time_t now = time(NULL);
+                long duration = (pss->connection_established > 0) ?
+                    (long)(now - pss->connection_established) : 0;
+                
+                // Determine closure reason
+                const char* reason = "client_disconnect";
+                if (g_shutdown_flag || !g_server_running) {
+                    reason = "server_shutdown";
+                }
+                
+                // Format authentication status
+                char auth_status[80];
+                if (pss->authenticated && strlen(pss->authenticated_pubkey) > 0) {
+                    // Show first 8 chars of pubkey for identification
+                    snprintf(auth_status, sizeof(auth_status), "yes(%.8s...)", pss->authenticated_pubkey);
+                } else {
+                    snprintf(auth_status, sizeof(auth_status), "no");
+                }
+                
+                // Log comprehensive closure information
+                DEBUG_LOG("WebSocket CLOSED: ip=%s duration=%lds subscriptions=%d authenticated=%s reason=%s",
+                    pss->client_ip,
+                    duration,
+                    pss->subscription_count,
+                    auth_status,
+                    reason);
+
+                // Clean up session subscriptions
                pthread_mutex_lock(&pss->session_lock);

                struct subscription* sub = pss->subscriptions;
@@ -931,6 +1020,8 @@ static int nostr_relay_callback(struct lws *wsi, enum lws_callback_reasons reaso

                pthread_mutex_unlock(&pss->session_lock);
                pthread_mutex_destroy(&pss->session_lock);
+            } else {
+                DEBUG_LOG("WebSocket CLOSED: ip=unknown duration=0s subscriptions=0 authenticated=no reason=unknown");
            }
            DEBUG_TRACE("WebSocket connection cleanup complete");
            break;
--- a/src/websockets.h
+++ b/src/websockets.h
@@ -38,6 +38,7 @@ struct per_session_data {
    pthread_mutex_t session_lock;           // Per-session thread safety
    char client_ip[CLIENT_IP_MAX_LENGTH];   // Client IP for logging
    int subscription_count;                  // Number of subscriptions for this session
+    time_t connection_established;           // When WebSocket connection was established

    // NIP-42 Authentication State
    char authenticated_pubkey[65];           // Authenticated public key (64 hex + null)
--- a/tests/ephemeral_test.sh
+++ b/tests/ephemeral_test.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+# Simplified Ephemeral Event Test
+# Tests that ephemeral events are broadcast to active subscriptions
+
+echo "=== Generating Ephemeral Event (kind 20000) ==="
+event=$(nak event --kind 20000 --content "test ephemeral event")
+echo "$event"
+echo ""
+
+echo "=== Testing Ephemeral Event Broadcast ==="
+subscription='["REQ","test_sub",{"kinds":[20000],"limit":10}]'
+echo "Subscription Filter:"
+echo "$subscription"
+echo ""
+
+event_msg='["EVENT",'"$event"']'
+echo "Event Message:"
+echo "$event_msg"
+echo ""
+
+echo "=== Relay Responses ==="
+(
+    # Send subscription
+    printf "%s\n" "$subscription"
+    # Wait for subscription to establish
+    sleep 1
+    # Send ephemeral event on same connection
+    printf "%s\n" "$event_msg"
+    # Wait for responses
+    sleep 2
+) | timeout 5 websocat ws://127.0.0.1:8888
+
+echo ""
+echo "Test complete!"
--- a/1
+++ b/1
Author	SHA1	Message	Date
Your Name	9cb9b746d8	v0.7.33 - Refactor monitoring system to use subscription-based activation with ephemeral events - fixes recursive crash bug	2025-10-19 10:26:09 -04:00
Your Name	57a0089664	v0.7.32 - Implement ephemeral event bypass (NIP-01) - events with kinds 20000-29999 are now broadcast to subscriptions but never stored in database, preventing recursive monitoring event loops	2025-10-19 09:38:02 -04:00
Your Name	53f7608872	v0.7.31 - Fixed production crash by replacing in-memory subscription iteration with database queries in monitoring system	2025-10-18 18:09:13 -04:00
Your Name	838ce5b45a	v0.7.30 - Update increment and push script	2025-10-18 15:04:45 -04:00
Your Name	e878b9557e	v0.7.29 - Update increment and push script	2025-10-18 14:57:34 -04:00
Your Name	6638d37d6f	v0.7.28 - Update increment and push script	2025-10-18 14:55:51 -04:00
Your Name	4c29e15329	v0.7.27 - Update increment and push script	2025-10-18 14:53:37 -04:00
Your Name	48890a2121	v0.7.26 - Tidy up api	2025-10-18 14:48:16 -04:00