pg_reports 0.1.0

data/app/views/pg_reports/dashboard/show.html.erb

@@ -0,0 +1,481 @@
+<%= csrf_meta_tags %>
+
+<div class="report-page">
+  <nav class="breadcrumb">
+    <%= link_to "Dashboard", root_path %>
+    <span>/</span>
+    <span><%= @categories[@category][:name] %></span>
+    <span>/</span>
+    <span><%= @report_info[:name] %></span>
+  </nav>
+
+  <div class="report-header">
+    <div class="report-info">
+      <h2><%= @report_info[:name] %></h2>
+      <p><%= @report_info[:description] %></p>
+    </div>
+
+    <div class="report-actions">
+      <button class="btn btn-primary" onclick="runReport('<%= @category %>', '<%= @report_key %>', this)">
+        ▶ Run Report
+      </button>
+
+      <!-- Download dropdown -->
+      <div class="dropdown" id="download-dropdown" style="display: none;">
+        <button class="btn btn-secondary" onclick="toggleDropdown()">
+          ⬇ Download
+        </button>
+        <div class="dropdown-menu" id="dropdown-menu">
+          <a href="#" onclick="downloadReport('txt'); return false;">📄 Text (.txt)</a>
+          <a href="#" onclick="downloadReport('csv'); return false;">📊 CSV (.csv)</a>
+          <a href="#" onclick="downloadReport('json'); return false;">📋 JSON (.json)</a>
+        </div>
+      </div>
+
+      <% if PgReports.config.telegram_configured? %>
+        <button class="btn btn-telegram" onclick="sendToTelegram('<%= @category %>', '<%= @report_key %>', this)" id="telegram-btn" style="display: none;">
+          📨 Telegram
+        </button>
+      <% end %>
+      <%= link_to "← Back", root_path, class: "btn btn-secondary" %>
+    </div>
+  </div>
+
+  <% if @error %>
+    <div class="error-message">
+      <strong>Error:</strong> <%= @error %>
+    </div>
+  <% end %>
+
+  <div class="results-container" id="results-container">
+    <div class="results-header">
+      <span class="results-title">Results</span>
+      <div class="results-meta" id="results-meta">
+        <span>Click "Run Report" to fetch data</span>
+      </div>
+    </div>
+
+    <div id="loading" class="loading" style="display: none;">
+      <div class="spinner"></div>
+    </div>
+
+    <div id="empty-state" class="empty-state" style="display: none;">
+      <div class="empty-state-icon">✓</div>
+      <p>No issues found. Everything looks good!</p>
+    </div>
+
+    <div class="results-table-wrapper">
+      <table class="results-table" id="results-table">
+        <thead id="results-head"></thead>
+        <tbody id="results-body"></tbody>
+      </table>
+    </div>
+  </div>
+</div>
+
+<style>
+  .dropdown {
+    position: relative;
+    display: inline-block;
+  }
+
+  .dropdown-menu {
+    display: none;
+    position: absolute;
+    top: 100%;
+    left: 0;
+    margin-top: 4px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 10px;
+    min-width: 160px;
+    box-shadow: 0 10px 40px rgba(0, 0, 0, 0.3);
+    z-index: 100;
+    overflow: hidden;
+  }
+
+  .dropdown-menu.show {
+    display: block;
+  }
+
+  .dropdown-menu a {
+    display: block;
+    padding: 0.75rem 1rem;
+    color: var(--text-secondary);
+    text-decoration: none;
+    font-size: 0.875rem;
+    transition: all 0.15s;
+  }
+
+  .dropdown-menu a:hover {
+    background: var(--bg-tertiary);
+    color: var(--text-primary);
+  }
+
+  .dropdown-menu a:not(:last-child) {
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  /* Clickable rows */
+  .results-table tbody tr.data-row {
+    cursor: pointer;
+    transition: all 0.15s;
+  }
+
+  .results-table tbody tr.data-row:hover {
+    background: var(--bg-secondary);
+  }
+
+  .results-table tbody tr.data-row.expanded {
+    background: var(--bg-tertiary);
+  }
+
+  .results-table tbody tr.data-row td:first-child::before {
+    content: '▸';
+    display: inline-block;
+    margin-right: 0.5rem;
+    color: var(--text-muted);
+    transition: transform 0.2s;
+  }
+
+  .results-table tbody tr.data-row.expanded td:first-child::before {
+    content: '▾';
+    color: var(--accent-purple);
+  }
+
+  /* Expanded row detail */
+  .results-table tbody tr.detail-row {
+    display: none;
+  }
+
+  .results-table tbody tr.detail-row.show {
+    display: table-row;
+  }
+
+  .results-table tbody tr.detail-row td {
+    padding: 0;
+    background: var(--bg-primary);
+    border-bottom: 2px solid var(--accent-purple);
+  }
+
+  .row-detail {
+    padding: 1.25rem;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1rem;
+  }
+
+  .row-detail-item {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+  }
+
+  .row-detail-item.full-width {
+    grid-column: 1 / -1;
+  }
+
+  .row-detail-label {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .row-detail-value {
+    padding: 0.75rem 1rem;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 0.8rem;
+    color: var(--text-primary);
+    white-space: pre-wrap;
+    word-break: break-word;
+    max-height: 200px;
+    overflow-y: auto;
+  }
+
+  .row-detail-value.query {
+    color: var(--accent-green);
+    max-height: 300px;
+  }
+
+  .row-detail-value.number {
+    color: var(--accent-blue);
+  }
+
+  .row-detail-value.source {
+    color: var(--accent-amber);
+    font-size: 0.75rem;
+  }
+
+  /* Source location badge in table */
+  .source-badge {
+    display: inline-block;
+    padding: 0.25rem 0.5rem;
+    background: rgba(245, 158, 11, 0.15);
+    border: 1px solid rgba(245, 158, 11, 0.3);
+    border-radius: 6px;
+    font-family: 'JetBrains Mono', monospace;
+    font-size: 0.7rem;
+    color: var(--accent-amber);
+    white-space: nowrap;
+    max-width: 200px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .source-badge.empty {
+    background: var(--bg-tertiary);
+    border-color: var(--border-color);
+    color: var(--text-muted);
+    font-style: italic;
+  }
+
+  /* Copy button */
+  .copy-btn {
+    align-self: flex-start;
+    margin-top: 0.375rem;
+    padding: 0.25rem 0.625rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    color: var(--text-muted);
+    font-size: 0.7rem;
+    cursor: pointer;
+    transition: all 0.15s;
+  }
+
+  .copy-btn:hover {
+    background: var(--accent-purple);
+    border-color: var(--accent-purple);
+    color: white;
+  }
+
+  /* Row hint */
+  .row-hint {
+    display: inline-block;
+    margin-left: 0.5rem;
+    padding: 0.125rem 0.5rem;
+    background: var(--bg-tertiary);
+    border-radius: 4px;
+    font-size: 0.7rem;
+    color: var(--text-muted);
+  }
+</style>
+
+<script>
+  let currentReportData = null;
+  const category = '<%= @category %>';
+  const reportKey = '<%= @report_key %>';
+
+  function toggleDropdown() {
+    document.getElementById('dropdown-menu').classList.toggle('show');
+  }
+
+  // Close dropdown when clicking outside
+  document.addEventListener('click', function(e) {
+    const dropdown = document.getElementById('download-dropdown');
+    if (dropdown && !dropdown.contains(e.target)) {
+      document.getElementById('dropdown-menu')?.classList.remove('show');
+    }
+  });
+
+  function downloadReport(format) {
+    document.getElementById('dropdown-menu').classList.remove('show');
+    window.location.href = `${pgReportsRoot}/${category}/${reportKey}/download?format=${format}`;
+  }
+
+  function toggleRow(rowIndex) {
+    const dataRow = document.getElementById(`data-row-${rowIndex}`);
+    const detailRow = document.getElementById(`detail-row-${rowIndex}`);
+
+    if (!dataRow || !detailRow) return;
+
+    const isExpanded = dataRow.classList.contains('expanded');
+
+    // Collapse all other rows
+    document.querySelectorAll('.data-row.expanded').forEach(row => {
+      row.classList.remove('expanded');
+    });
+    document.querySelectorAll('.detail-row.show').forEach(row => {
+      row.classList.remove('show');
+    });
+
+    // Toggle current row
+    if (!isExpanded) {
+      dataRow.classList.add('expanded');
+      detailRow.classList.add('show');
+    }
+  }
+
+  function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+  }
+
+  function copyToClipboard(text, btn) {
+    navigator.clipboard.writeText(text).then(() => {
+      const originalText = btn.textContent;
+      btn.textContent = '✓ Copied!';
+      btn.style.background = 'var(--accent-green)';
+      btn.style.borderColor = 'var(--accent-green)';
+      btn.style.color = 'white';
+      setTimeout(() => {
+        btn.textContent = originalText;
+        btn.style.background = '';
+        btn.style.borderColor = '';
+        btn.style.color = '';
+      }, 1500);
+    }).catch(() => {
+      showToast('Failed to copy', 'error');
+    });
+  }
+
+  function buildDetailRow(row, columns, rowIndex) {
+    let html = '<div class="row-detail">';
+
+    columns.forEach(col => {
+      const value = row[col] ?? '';
+      const strValue = String(value);
+      const isQuery = col === 'query';
+      const isSource = col === 'source';
+      const isNumber = typeof value === 'number' || (!isNaN(parseFloat(value)) && isFinite(value));
+
+      let valueClass = '';
+      if (isQuery) valueClass = 'query';
+      else if (isSource) valueClass = 'source';
+      else if (isNumber) valueClass = 'number';
+
+      const isLongText = strValue.length > 100 || isQuery;
+
+      // Skip empty source in detail view
+      if (isSource && (!strValue || strValue === 'null' || strValue === '')) {
+        return;
+      }
+
+      html += `
+        <div class="row-detail-item${isLongText ? ' full-width' : ''}">
+          <span class="row-detail-label">${escapeHtml(col)}</span>
+          <div class="row-detail-value ${valueClass}">${escapeHtml(strValue)}</div>
+          ${isQuery ? `<button class="copy-btn" onclick="event.stopPropagation(); copyToClipboard(\`${strValue.replace(/`/g, '\\`').replace(/\\/g, '\\\\')}\`, this)">📋 Copy Query</button>` : ''}
+        </div>
+      `;
+    });
+
+    html += '</div>';
+    return html;
+  }
+
+  async function runReport(cat, report, button) {
+    const tableBody = document.getElementById('results-body');
+    const tableHead = document.getElementById('results-head');
+    const loadingEl = document.getElementById('loading');
+    const emptyEl = document.getElementById('empty-state');
+    const metaEl = document.getElementById('results-meta');
+    const downloadDropdown = document.getElementById('download-dropdown');
+    const telegramBtn = document.getElementById('telegram-btn');
+
+    if (button) {
+      button.disabled = true;
+      button.innerHTML = '<span class="spinner" style="width:16px;height:16px;border-width:2px;display:inline-block;vertical-align:middle;"></span> Running...';
+    }
+
+    if (loadingEl) loadingEl.style.display = 'flex';
+    if (emptyEl) emptyEl.style.display = 'none';
+    if (tableBody) tableBody.innerHTML = '';
+    if (downloadDropdown) downloadDropdown.style.display = 'none';
+    if (telegramBtn) telegramBtn.style.display = 'none';
+
+    try {
+      const response = await fetch(`${pgReportsRoot}/${cat}/${report}/run`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]')?.content || ''
+        }
+      });
+
+      const data = await response.json();
+
+      if (loadingEl) loadingEl.style.display = 'none';
+
+      if (data.success) {
+        currentReportData = data;
+
+        if (metaEl) {
+          metaEl.innerHTML = `
+            <span>Total: ${data.total} rows</span>
+            <span>Generated: ${data.generated_at}</span>
+            <span class="row-hint">Click row to expand</span>
+          `;
+        }
+
+        // Show download and telegram buttons
+        if (downloadDropdown) downloadDropdown.style.display = 'inline-block';
+        if (telegramBtn) telegramBtn.style.display = 'inline-flex';
+
+        if (data.data.length === 0) {
+          if (emptyEl) emptyEl.style.display = 'block';
+        } else {
+          // Build table header
+          if (tableHead) {
+            tableHead.innerHTML = '<tr>' + data.columns.map(col =>
+              `<th>${escapeHtml(col)}</th>`
+            ).join('') + '</tr>';
+          }
+
+          // Build table body with expandable rows
+          if (tableBody) {
+            let rowsHtml = '';
+
+            data.data.forEach((row, idx) => {
+              // Data row
+              rowsHtml += `<tr id="data-row-${idx}" class="data-row" onclick="toggleRow(${idx})">`;
+              rowsHtml += data.columns.map(col => {
+                const value = row[col] ?? '';
+                const strValue = String(value);
+                const isQuery = col === 'query';
+                const isSource = col === 'source';
+
+                if (isSource) {
+                  if (strValue && strValue !== 'null' && strValue !== '') {
+                    return `<td><span class="source-badge" title="${escapeHtml(strValue)}">${escapeHtml(strValue)}</span></td>`;
+                  } else {
+                    return `<td><span class="source-badge empty">—</span></td>`;
+                  }
+                }
+
+                const displayValue = strValue.length > 80 ? strValue.substring(0, 80) + '...' : strValue;
+                return `<td class="${isQuery ? 'query-cell' : ''}">${escapeHtml(displayValue)}</td>`;
+              }).join('');
+              rowsHtml += '</tr>';
+
+              // Detail row (hidden by default)
+              rowsHtml += `<tr id="detail-row-${idx}" class="detail-row">`;
+              rowsHtml += `<td colspan="${data.columns.length}">${buildDetailRow(row, data.columns, idx)}</td>`;
+              rowsHtml += '</tr>';
+            });
+
+            tableBody.innerHTML = rowsHtml;
+          }
+        }
+
+        showToast('Report generated successfully');
+      } else {
+        showToast(data.error || 'Failed to run report', 'error');
+      }
+    } catch (error) {
+      if (loadingEl) loadingEl.style.display = 'none';
+      showToast('Network error: ' + error.message, 'error');
+    }
+
+    if (button) {
+      button.disabled = false;
+      button.innerHTML = '▶ Run Report';
+    }
+  }
+</script>

data/config/routes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+PgReports::Engine.routes.draw do
+  root to: "dashboard#index"
+
+  post "enable_pg_stat_statements", to: "dashboard#enable_pg_stat_statements", as: :enable_pg_stat_statements
+  post "reset_statistics", to: "dashboard#reset_statistics", as: :reset_statistics
+
+  get ":category/:report", to: "dashboard#show", as: :report
+  post ":category/:report/run", to: "dashboard#run", as: :run_report
+  post ":category/:report/telegram", to: "dashboard#send_to_telegram", as: :telegram_report
+  get ":category/:report/download", to: "dashboard#download", as: :download_report
+end

data/lib/pg_reports/annotation_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module PgReports
+  # Parses SQL query comments to extract source location and metadata
+  # Supports:
+  # - Marginalia format: /*application:myapp,controller:users,action:index*/
+  # - Rails QueryLogs: /*action='index',controller='users'*/
+  #
+  module AnnotationParser
+    class << self
+      # Parse annotation from query text
+      # @param query [String] SQL query text
+      # @return [Hash] Parsed annotation data
+      def parse(query)
+        return {} if query.nil? || query.empty?
+
+        # Extract all comments from query
+        comments = query.scan(%r{/\*(.+?)\*/}).flatten
+
+        return {} if comments.empty?
+
+        result = {}
+
+        comments.each do |comment|
+          # Try short format first: "path/to/file.rb:42"
+          if (match = comment.match(%r{^(.+):(\d+)$}))
+            result[:file] = match[1]
+            result[:line] = match[2]
+          else
+            parsed = parse_comment(comment)
+            result.merge!(parsed)
+          end
+        end
+
+        result
+      end
+
+      # Extract clean query without annotations
+      # @param query [String] SQL query with annotations
+      # @return [String] Clean query
+      def strip_annotations(query)
+        return query if query.nil?
+
+        query.gsub(%r{/\*.+?\*/\s*}, "").strip
+      end
+
+      # Format annotation for display
+      # @param annotation [Hash] Parsed annotation
+      # @return [String] Human-readable string
+      def format_for_display(annotation)
+        return nil if annotation.empty?
+
+        parts = []
+
+        # Source location
+        if annotation[:file]
+          loc = annotation[:file].to_s
+          loc += ":#{annotation[:line]}" if annotation[:line]
+          parts << loc
+        end
+
+        # Method
+        parts << "##{annotation[:method]}" if annotation[:method]
+
+        # Controller/action
+        if annotation[:controller]
+          ca = annotation[:controller].to_s
+          ca += "##{annotation[:action]}" if annotation[:action]
+          parts << ca
+        end
+
+        parts.join(" ")
+      end
+
+      private
+
+      def parse_comment(comment)
+        result = {}
+
+        # Try different formats
+
+        # Format 1: key:value,key:value (Marginalia/PgReports style)
+        if comment.include?(":")
+          comment.split(",").each do |pair|
+            key, value = pair.split(":", 2)
+            next unless key && value
+
+            key = normalize_key(key.strip)
+            result[key] = value.strip
+          end
+        end
+
+        # Format 2: key='value',key='value' (Rails QueryLogs style)
+        if comment.include?("=")
+          comment.scan(/(\w+)='([^']*)'/).each do |key, value|
+            key = normalize_key(key)
+            result[key] = value
+          end
+
+          comment.scan(/(\w+)="([^"]*)"/).each do |key, value|
+            key = normalize_key(key)
+            result[key] = value
+          end
+        end
+
+        result
+      end
+
+      def normalize_key(key)
+        key.downcase.gsub(/[-\s]/, "_").to_sym
+      end
+    end
+  end
+end

data/lib/pg_reports/configuration.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PgReports
+  class Configuration
+    # Telegram settings
+    attr_accessor :telegram_bot_token
+    attr_accessor :telegram_chat_id
+
+    # Query analysis thresholds
+    attr_accessor :slow_query_threshold_ms      # Queries slower than this are considered slow
+    attr_accessor :heavy_query_threshold_calls  # Queries with more calls than this are heavy
+    attr_accessor :expensive_query_threshold_ms # Total time threshold for expensive queries
+
+    # Index analysis thresholds
+    attr_accessor :unused_index_threshold_scans # Index with fewer scans is unused
+
+    # Table analysis thresholds
+    attr_accessor :bloat_threshold_percent      # Tables with more bloat are problematic
+    attr_accessor :dead_rows_threshold          # Tables with more dead rows need vacuum
+
+    # Connection settings
+    attr_accessor :connection_pool              # Custom connection pool (optional)
+
+    # Output settings
+    attr_accessor :max_query_length             # Truncate query text to this length
+
+    # Dashboard settings
+    attr_accessor :dashboard_auth               # Proc for dashboard authentication
+
+    def initialize
+      # Telegram
+      @telegram_bot_token = ENV.fetch("PG_REPORTS_TELEGRAM_TOKEN", nil)
+      @telegram_chat_id = ENV.fetch("PG_REPORTS_TELEGRAM_CHAT_ID", nil)
+
+      # Query thresholds
+      @slow_query_threshold_ms = 100
+      @heavy_query_threshold_calls = 1000
+      @expensive_query_threshold_ms = 10_000
+
+      # Index thresholds
+      @unused_index_threshold_scans = 50
+
+      # Table thresholds
+      @bloat_threshold_percent = 20
+      @dead_rows_threshold = 10_000
+
+      # Connection
+      @connection_pool = nil
+
+      # Output
+      @max_query_length = 200
+
+      # Dashboard
+      @dashboard_auth = nil
+    end
+
+    def connection
+      @connection_pool || ActiveRecord::Base.connection
+    end
+
+    def telegram_configured?
+      telegram_bot_token.present? && telegram_chat_id.present?
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def config
+      configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end