v0.7.26 - Tidy up api

.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

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 {
@@ -545,6 +553,7 @@ button:disabled {
 .inline-buttons {
     display: flex;
     gap: 10px;
+    flex-wrap: nowrap;
 }
 
 .inline-buttons button {
@@ -655,9 +664,9 @@ button:disabled {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    margin-bottom: 15px;
+    /* margin-bottom: 15px; */
-    border-bottom: var(--border-width) solid var(--border-color);
+    /* border-bottom: var(--border-width) solid var(--border-color); */
-    padding-bottom: 10px;
+    /* padding-bottom: 10px; */
 }
 
 .countdown-btn {
@@ -1002,34 +1011,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 {
+/* Config Toggle Button Styles */
-        flex-direction: column;
+.config-toggle-btn {
-    }
+    width: 24px;
-
+    height: 24px;
-    .query-actions {
+    padding: 0;
-        flex-direction: column;
+    background: var(--secondary-color);
-    }
+    border: var(--border-width) solid var(--border-color);
-
+    border-radius: var(--border-radius);
-    h1 {
+    font-family: var(--font-family);
-        font-size: 20px;
+    font-size: 14px;
-    }
+    cursor: pointer;
-
+    margin-left: 10px;
-    h2 {
+    font-weight: bold;
-        font-size: 14px;
+    transition: all 0.2s ease;
-    }
+    display: flex;
-
+    align-items: center;
-    .sql-results-table {
+    justify-content: center;
-        font-size: 10px;
+}
-    }
+
-
+/* Toggle Button Styles */
-    .sql-results-table th,
+.toggle-btn {
-    .sql-results-table td {
+    width: auto;
-        padding: 4px 6px;
+    min-width: 120px;
-        max-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;
+}
+
+.toggle-btn:hover {
+    border-color: var(--accent-color);
+}
+
+.toggle-btn:active {
+    background: var(--accent-color);
+    color: var(--secondary-color);
+}
+
+.config-toggle-btn:hover {
+    border-color: var(--accent-color);
+}
+
+.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;
 }

api/index.html

@@ -54,9 +54,13 @@
     <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 toggle button will be inserted here by JavaScript -->
+            <!-- Temporarily disable auto-refresh button for real-time monitoring -->
+            <!-- <button type="button" id="refresh-stats-btn" class="countdown-btn"></button> -->
         </div>
 
+        <!-- Event Rate Graph Container -->
+        <div id="event-rate-chart"></div>
 
         <!-- Database Overview Table -->
         <div class="input-group">
@@ -77,6 +81,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 +172,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 +344,11 @@
 
         <!-- Query Actions -->
         <div class="input-group">
-            <button type="button" id="execute-sql-btn" class="primary-button">EXECUTE QUERY</button>
+            <div class="inline-buttons">
-            <button type="button" id="clear-sql-btn">CLEAR</button>
+                <button type="button" id="execute-sql-btn">EXECUTE QUERY</button>
-            <button type="button" id="clear-history-btn" class="danger-button">CLEAR HISTORY</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 +366,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>
 
 
 

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';
+        }
+    }
+}

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

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.

relay.pid

@@ -1 +1 @@
-752613
+3159561

src/api.c

@@ -20,12 +20,537 @@
 #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
+static time_t last_report_time = 0;
+
+// 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 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);
+}
+
+int set_monitoring_enabled(int enabled) {
+    const char* value = enabled ? "1" : "0";
+    if (update_config_in_table("kind_34567_reporting_enabled", value) == 0) {
+        DEBUG_INFO("Monitoring enabled state changed");
+        return 0;
+    }
+    return -1;
+}
+
+// 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 from in-memory manager (NO DATABASE QUERY)
+cJSON* query_active_subscriptions(void) {
+    // Access the global subscription manager
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+
+    int total_subs = g_subscription_manager.total_subscriptions;
+    int max_subs = g_subscription_manager.max_total_subscriptions;
+    int max_per_client = g_subscription_manager.max_subscriptions_per_client;
+
+    // Calculate per-client statistics by iterating through active subscriptions
+    int client_count = 0;
+    int most_subs_per_client = 0;
+
+    // Count subscriptions per WebSocket connection
+    subscription_t* current = g_subscription_manager.active_subscriptions;
+    struct lws* last_wsi = NULL;
+    int current_client_subs = 0;
+
+    while (current) {
+        if (current->wsi != last_wsi) {
+            // New client
+            if (last_wsi != NULL) {
+                client_count++;
+                if (current_client_subs > most_subs_per_client) {
+                    most_subs_per_client = current_client_subs;
+                }
+            }
+            last_wsi = current->wsi;
+            current_client_subs = 1;
+        } else {
+            current_client_subs++;
+        }
+        current = current->next;
+    }
+
+    // Handle last client
+    if (last_wsi != NULL) {
+        client_count++;
+        if (current_client_subs > most_subs_per_client) {
+            most_subs_per_client = current_client_subs;
+        }
+    }
+
+    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+
+    // 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 in-memory manager (ADMIN ONLY)
+cJSON* query_subscription_details(void) {
+    // Access the global subscription manager
+    pthread_mutex_lock(&g_subscription_manager.subscriptions_lock);
+
+    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 all active subscriptions
+    subscription_t* current = g_subscription_manager.active_subscriptions;
+    while (current) {
+        cJSON* sub_obj = cJSON_CreateObject();
+
+        // Basic subscription info
+        cJSON_AddStringToObject(sub_obj, "id", current->id);
+        cJSON_AddStringToObject(sub_obj, "client_ip", current->client_ip);
+        cJSON_AddNumberToObject(sub_obj, "created_at", (double)current->created_at);
+        cJSON_AddNumberToObject(sub_obj, "duration_seconds", (double)(current_time - current->created_at));
+        cJSON_AddNumberToObject(sub_obj, "events_sent", current->events_sent);
+        cJSON_AddBoolToObject(sub_obj, "active", current->active);
+
+        // Extract filter details
+        cJSON* filters_array = cJSON_CreateArray();
+        subscription_filter_t* filter = current->filters;
+
+        while (filter) {
+            cJSON* filter_obj = cJSON_CreateObject();
+
+            // Add kinds array if present
+            if (filter->kinds) {
+                cJSON_AddItemToObject(filter_obj, "kinds", cJSON_Duplicate(filter->kinds, 1));
+            }
+
+            // Add authors array if present
+            if (filter->authors) {
+                cJSON_AddItemToObject(filter_obj, "authors", cJSON_Duplicate(filter->authors, 1));
+            }
+
+            // Add ids array if present
+            if (filter->ids) {
+                cJSON_AddItemToObject(filter_obj, "ids", cJSON_Duplicate(filter->ids, 1));
+            }
+
+            // Add since/until timestamps if set
+            if (filter->since > 0) {
+                cJSON_AddNumberToObject(filter_obj, "since", (double)filter->since);
+            }
+            if (filter->until > 0) {
+                cJSON_AddNumberToObject(filter_obj, "until", (double)filter->until);
+            }
+
+            // Add limit if set
+            if (filter->limit > 0) {
+                cJSON_AddNumberToObject(filter_obj, "limit", filter->limit);
+            }
+
+            // Add tag filters if present
+            if (filter->tag_filters) {
+                cJSON_AddItemToObject(filter_obj, "tag_filters", cJSON_Duplicate(filter->tag_filters, 1));
+            }
+
+            cJSON_AddItemToArray(filters_array, filter_obj);
+            filter = filter->next;
+        }
+
+        cJSON_AddItemToObject(sub_obj, "filters", filters_array);
+        cJSON_AddItemToArray(subscriptions_array, sub_obj);
+
+        current = current->next;
+    }
+
+    pthread_mutex_unlock(&g_subscription_manager.subscriptions_lock);
+
+    // 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 34567)
+    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", 34567);
+    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(
+        34567,                              // kind
+        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 event to active subscriptions
+    broadcast_event_to_subscriptions(monitoring_event);
+
+    // Store in database
+    int store_result = store_event(monitoring_event);
+
+    cJSON_Delete(monitoring_event);
+    free(content_json);
+
+    if (store_result != 0) {
+        DEBUG_ERROR("Failed to store monitoring event (%s)", d_tag_value);
+        return -1;
+    }
+
+    return 0;
+}
+
+// Monitoring hook 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 report
+    }
+
+    // Generate and broadcast monitoring event
+    if (generate_monitoring_event() == 0) {
+        last_report_time = now;
+    }
+}
+
+// Initialize monitoring system
+int init_monitoring_system(void) {
+    last_report_time = 0;
+    DEBUG_INFO("Monitoring system initialized");
+    return 0;
+}
+
+// Cleanup monitoring system
+void cleanup_monitoring_system(void) {
+    // No cleanup needed for monitoring system
+    DEBUG_INFO("Monitoring system cleaned up");
+}
+
 // Forward declaration for known_configs (defined in config.c)
 typedef struct {
     const char* key;
@@ -107,9 +632,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
+// Forward declaration for monitoring helper function
-int store_event(cJSON* event);
+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 +1162,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 +1446,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 +1490,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 +2220,124 @@ 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 commands
+    if (strcmp(cmd, "enable_monitoring") == 0) {
+        if (set_monitoring_enabled(1) == 0) {
+            char* response_content = "✅ Monitoring enabled\n\nReal-time monitoring events will now be generated.";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        } else {
+            char* response_content = "❌ Failed to enable monitoring";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        }
+    } else if (strcmp(cmd, "disable_monitoring") == 0) {
+        if (set_monitoring_enabled(0) == 0) {
+            char* response_content = "✅ Monitoring disabled\n\nReal-time monitoring events will no longer be generated.";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        } else {
+            char* response_content = "❌ Failed to disable monitoring";
+            return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+        }
+    } else 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_34567_reporting_throttling_sec", throttle_str) == 0) {
+            char response_content[256];
+            snprintf(response_content, sizeof(response_content),
+                    "✅ Monitoring throttle updated\n\nMinimum interval between monitoring events: %ld seconds", 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 if (strcmp(cmd, "monitoring_status") == 0) {
+        int enabled = is_monitoring_enabled();
+        int throttle = get_monitoring_throttle_seconds();
+
+        char response_content[512];
+        snprintf(response_content, sizeof(response_content),
+                "📊 Monitoring Status\n"
+                "━━━━━━━━━━━━━━━━━━━━\n"
+                "\n"
+                "Enabled: %s\n"
+                "Throttle: %d seconds\n"
+                "\n"
+                "Commands:\n"
+                "• enable_monitoring\n"
+                "• disable_monitoring\n"
+                "• set_monitoring_throttle <seconds>\n"
+                "• monitoring_status",
+                enabled ? "Yes" : "No", throttle);
+
+        return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+    } else {
+        char response_content[256];
+        snprintf(response_content, sizeof(response_content),
+                "❌ Unknown monitoring command: %s\n\n"
+                "Available commands:\n"
+                "• enable_monitoring\n"
+                "• disable_monitoring\n"
+                "• set_monitoring_throttle <seconds>\n"
+                "• monitoring_status", cmd);
+        return send_admin_response(sender_pubkey, response_content, request_id, error_message, error_size, wsi);
+    }
+}

src/api.h

@@ -59,4 +59,12 @@ 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
+int init_monitoring_system(void);
+void cleanup_monitoring_system(void);
+void monitoring_on_event_stored(void);
+int set_monitoring_enabled(int enabled);
+int is_monitoring_enabled(void);
+int get_monitoring_throttle_seconds(void);
+
 #endif // API_H

src/config.c

@@ -4099,6 +4099,37 @@ int populate_all_config_values_atomic(const char* admin_pubkey, const char* rela
         return -1;
     }
 
+    // Insert monitoring system config entries
+    sqlite3_reset(stmt);
+    sqlite3_bind_text(stmt, 1, "kind_34567_reporting_enabled", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 2, "false", -1, SQLITE_STATIC);  // boolean, default false
+    sqlite3_bind_text(stmt, 3, "boolean", -1, SQLITE_STATIC);
+    sqlite3_bind_text(stmt, 4, "Enable real-time monitoring event generation", -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_34567_reporting_enabled: %s", sqlite3_errmsg(g_db));
+        sqlite3_finalize(stmt);
+        sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
+        return -1;
+    }
+
+    sqlite3_reset(stmt);
+    sqlite3_bind_text(stmt, 1, "kind_34567_reporting_throttling_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", -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_34567_reporting_throttling_sec: %s", sqlite3_errmsg(g_db));
+        sqlite3_finalize(stmt);
+        sqlite3_exec(g_db, "ROLLBACK;", NULL, NULL, NULL);
+        return -1;
+    }
+
     sqlite3_finalize(stmt);
 
     // Commit transaction

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"

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
 

src/main.c

@@ -149,6 +149,11 @@ 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 declarations for monitoring system
+void init_monitoring_system(void);
+void cleanup_monitoring_system(void);
+void monitoring_on_event_stored(void);
+
 // Forward declarations for NIP-11 relay information handling
 void init_relay_info();
 void cleanup_relay_info();
@@ -731,6 +736,10 @@ int store_event(cJSON* event) {
     }
 
     free(tags_json);
+
+    // Call monitoring hook after successful event storage
+    monitoring_on_event_stored();
+
     return 0;
 }
 
@@ -1979,6 +1988,10 @@ int main(int argc, char* argv[]) {
     
     // Initialize NIP-40 expiration configuration
     init_expiration_config();
+
+    // Initialize monitoring system
+    init_monitoring_system();
+
     // Update subscription manager configuration
     update_subscription_manager_config();
 
@@ -2010,6 +2023,9 @@ int main(int argc, char* argv[]) {
     ginxsom_request_validator_cleanup();
     cleanup_configuration_system();
 
+    // Cleanup monitoring system
+    cleanup_monitoring_system();
+
     // Cleanup subscription manager mutexes
     pthread_mutex_destroy(&g_subscription_manager.subscriptions_lock);
     pthread_mutex_destroy(&g_subscription_manager.ip_tracking_lock);

src/websockets.c

@@ -256,6 +256,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
@@ -913,10 +916,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 +962,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;

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)