feat: Add structured logging with integration into database and storage modules, enhance database connection configuration, and create API utilities.

Author: patrickrb

.env.example

@@ -1,6 +1,11 @@
 # Database
 DATABASE_URL=postgresql://username:password@localhost:5432/database_name
 
+# Database SSL Configuration
+# Set to 'true' to enable SSL for database connections (recommended for production)
+# Set to 'false' for local development
+DATABASE_SSL=false
+
 # Authentication
 JWT_SECRET=your-secret-key-here
 

src/app/api/cloudlog/bands/route.ts

@@ -4,6 +4,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { verifyApiKey } from '@/lib/api-auth';
 import { addCorsHeaders, createCorsPreflightResponse } from '@/lib/cors';
+import { addRateLimitHeaders } from '@/lib/api-utils';
 
 // Standard amateur radio bands with frequencies
 const AMATEUR_BANDS = [
@@ -46,7 +47,7 @@ export async function OPTIONS() {
 
 export async function GET(request: NextRequest) {
   const authResult = await verifyApiKey(request);
-  
+
   if (!authResult.success) {
     const response = NextResponse.json({
       success: false,
@@ -57,7 +58,7 @@ export async function GET(request: NextRequest) {
 
   const auth = authResult.auth!;
   const url = new URL(request.url);
-  
+
   try {
     const bandFilter = url.searchParams.get('band');
     const format = url.searchParams.get('format') || 'detailed';
@@ -66,13 +67,13 @@ export async function GET(request: NextRequest) {
 
     // Filter by specific band if requested
     if (bandFilter) {
-      bands = bands.filter(b => 
+      bands = bands.filter(b =>
         b.band.toUpperCase() === bandFilter.toUpperCase()
       );
     }
 
     let responseData;
-    
+
     if (format === 'simple') {
       // Simple format - just band names
       responseData = bands.map(b => b.band);
@@ -83,8 +84,8 @@ export async function GET(request: NextRequest) {
         frequency_start_mhz: band.freq_start,
         frequency_end_mhz: band.freq_end,
         wavelength: band.wavelength,
-        type: band.band.includes('M') ? 'HF/VHF/UHF' : 
-              band.band.includes('CM') ? 'Microwave' : 'Millimeter'
+        type: band.band.includes('M') ? 'HF/VHF/UHF' :
+          band.band.includes('CM') ? 'Microwave' : 'Millimeter'
       }));
     }
 
@@ -96,9 +97,8 @@ export async function GET(request: NextRequest) {
     });
 
     // Add rate limit headers
-    response.headers.set('X-RateLimit-Limit', auth.rateLimitPerHour.toString());
-    response.headers.set('X-RateLimit-Remaining', '999'); // TODO: Get actual remaining
-    
+    addRateLimitHeaders(response, 999, auth.rateLimitPerHour);
+
     return addCorsHeaders(response);
 
   } catch (error) {

src/app/api/cloudlog/station/route.ts

@@ -4,10 +4,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { verifyApiKey, canAccessStation } from '@/lib/api-auth';
 import { query } from '@/lib/db';
+import { addRateLimitHeaders } from '@/lib/api-utils';
+import { logger } from '@/lib/logger';
 
 export async function GET(request: NextRequest) {
   const authResult = await verifyApiKey(request);
-  
+
   if (!authResult.success) {
     return NextResponse.json({
       success: false,
@@ -17,7 +19,7 @@ export async function GET(request: NextRequest) {
 
   const auth = authResult.auth!;
   const url = new URL(request.url);
-  
+
   try {
     const stationIdParam = url.searchParams.get('station_id');
     let stationId = auth.stationId;
@@ -111,14 +113,13 @@ export async function GET(request: NextRequest) {
       count: stations.length
     });
 
-    // Add rate limit headers
-    response.headers.set('X-RateLimit-Limit', auth.rateLimitPerHour.toString());
-    response.headers.set('X-RateLimit-Remaining', '999'); // TODO: Get actual remaining
-    
+    // Add rate limit headers  
+    addRateLimitHeaders(response, 999, auth.rateLimitPerHour);
+
     return response;
 
   } catch (error) {
-    console.error('Station retrieval error:', error);
+    logger.error('Station retrieval error', error);
     return NextResponse.json({
       success: false,
       error: 'Internal server error'

src/lib/api-utils.ts

@@ -0,0 +1,73 @@
+// API utility functions for Nextlog
+// Shared utilities for API routes
+
+import { NextResponse } from 'next/server';
+
+/**
+ * Add rate limiting headers to API responses
+ * @param response - NextResponse to add headers to
+ * @param remaining - Remaining requests in current window
+ * @param limit - Total rate limit per hour
+ * @param resetTime - Optional reset timestamp (defaults to 1 hour from now)
+ * @returns Response with rate limit headers added
+ */
+export function addRateLimitHeaders(
+    response: NextResponse,
+    remaining: number,
+    limit: number,
+    resetTime?: number
+): NextResponse {
+    const reset = resetTime || Math.floor(Date.now() / 1000 + 3600);
+
+    response.headers.set('X-RateLimit-Limit', limit.toString());
+    response.headers.set('X-RateLimit-Remaining', remaining.toString());
+    response.headers.set('X-RateLimit-Reset', reset.toString());
+
+    return response;
+}
+
+/**
+ * Create a JSON response with rate limit headers
+ * @param data - Response data
+ * @param status - HTTP status code
+ * @param remaining - Remaining requests
+ * @param limit - Rate limit per hour
+ * @returns NextResponse with JSON data and rate limit headers
+ */
+export function createRateLimitedResponse(
+    data: unknown,
+    status: number,
+    remaining: number,
+    limit: number
+): NextResponse {
+    const response = NextResponse.json(data, { status });
+    return addRateLimitHeaders(response, remaining, limit);
+}
+
+/**
+ * Create a successful JSON response with rate limit headers
+ * @param data - Response data
+ * @param remaining - Remaining requests
+ * @param limit - Rate limit per hour
+ * @returns NextResponse with JSON data and rate limit headers
+ */
+export function successWithRateLimit(
+    data: unknown,
+    remaining: number,
+    limit: number
+): NextResponse {
+    return createRateLimitedResponse(data, 200, remaining, limit);
+}
+
+/**
+ * Create an error response
+ * @param message - Error message
+ * @param status - HTTP status code
+ * @returns NextResponse with error
+ */
+export function errorResponse(
+    message: string,
+    status: number = 500
+): NextResponse {
+    return NextResponse.json({ error: message }, { status });
+}

src/lib/db.ts

@@ -1,6 +1,5 @@
-// Database connection utility for Nextlog PostgreSQL
-
 import { Pool, PoolClient, QueryResult } from 'pg';
+import { logger } from './logger';
 
 // Global connection pool
 let pool: Pool;
@@ -10,47 +9,51 @@ let pool: Pool;
  */
 function getPool(): Pool {
   if (!pool) {
+    const sslConfig = process.env.DATABASE_SSL === 'true'
+      ? { rejectUnauthorized: false }
+      : false;
+
     pool = new Pool({
       connectionString: process.env.DATABASE_URL,
-      ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
+      ssl: sslConfig,
       max: 20, // Maximum number of clients in the pool
-      idleTimeoutMillis: 30000, // Close idle clients after 30 seconds
-      connectionTimeoutMillis: 2000, // Return an error after 2 seconds if connection could not be established
+      idleTimeoutMillis: 60000, // Close idle clients after 60 seconds
+      connectionTimeoutMillis: 10000, // Return an error after 10 seconds if connection could not be established
+      query_timeout: 30000, // Query timeout: 30 seconds
+      statement_timeout: 30000, // Statement timeout: 30 seconds
     });
 
     // Handle pool errors
     pool.on('error', (err) => {
-      console.error('Unexpected error on idle client', err);
+      logger.error('Unexpected error on idle client', err);
     });
+
+    logger.info('Database connection pool initialized');
   }
 
   return pool;
 }
 
+
 /**
  * Execute a query using the connection pool
  */
 export async function query(text: string, params?: unknown[]): Promise<QueryResult> {
   const pool = getPool();
   const start = Date.now();
-  
+
   try {
     const result = await pool.query(text, params);
     const duration = Date.now() - start;
-    
+
     // Log slow queries (> 100ms)
     if (duration > 100) {
-      console.warn('Slow query detected:', {
-        duration: `${duration}ms`,
-        text: text.substring(0, 100) + (text.length > 100 ? '...' : ''),
-        params: params?.length ? `${params.length} params` : 'no params'
-      });
+      logger.slowQuery(duration, text, params);
     }
-    
+
     return result;
   } catch (error) {
-    console.error('Database query error:', {
-      error: error instanceof Error ? error.message : 'Unknown error',
+    logger.error('Database query error', error, {
       query: text.substring(0, 100) + (text.length > 100 ? '...' : ''),
       params: params?.length ? `${params.length} params` : 'no params'
     });
@@ -73,7 +76,7 @@ export async function transaction<T>(
   callback: (client: PoolClient) => Promise<T>
 ): Promise<T> {
   const client = await getClient();
-  
+
   try {
     await client.query('BEGIN');
     const result = await callback(client);
@@ -98,13 +101,13 @@ export async function closePool(): Promise<void> {
 
 // Handle process termination
 process.on('SIGINT', async () => {
-  console.log('Closing database pool...');
+  logger.info('Shutting down: Closing database pool');
   await closePool();
   process.exit(0);
 });
 
 process.on('SIGTERM', async () => {
-  console.log('Closing database pool...');
+  logger.info('Shutting down: Closing database pool');
   await closePool();
   process.exit(0);
 });

src/lib/logger.ts

@@ -0,0 +1,69 @@
+// Logging utility for Nextlog
+// Provides environment-aware, structured logging with different log levels
+
+interface LogContext {
+    [key: string]: unknown;
+}
+
+/**
+ * Structured logger with environment-aware log levels
+ */
+export const logger = {
+    /**
+     * Debug logging - only shown in development environment
+     * Use for detailed debugging information
+     */
+    debug: (message: string, context?: LogContext) => {
+        if (process.env.NODE_ENV === 'development') {
+            console.log(`[DEBUG] ${message}`, context || '');
+        }
+    },
+
+    /**
+     * Info logging - shown in all environments
+     * Use for general informational messages
+     */
+    info: (message: string, context?: LogContext) => {
+        console.log(`[INFO] ${message}`, context || '');
+    },
+
+    /**
+     * Warning logging - shown in all environments
+     * Use for Warning conditions that don't prevent operation
+     */
+    warn: (message: string, context?: LogContext) => {
+        console.warn(`[WARN] ${message}`, context || '');
+    },
+
+    /**
+     * Error logging - shown in all environments
+     * Use for error conditions that need attention
+     */
+    error: (message: string, error?: unknown, context?: LogContext) => {
+        const errorDetails = error instanceof Error ? {
+            message: error.message,
+            stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
+            ...context
+        } : { error, ...context };
+
+        console.error(`[ERROR] ${message}`, errorDetails);
+    },
+
+    /**
+     * Log slow database queries (development only)
+     */
+    slowQuery: (duration: number, query: string, params?: unknown) => {
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`[SLOW QUERY] ${duration}ms`, {
+                query: query.substring(0, 100) + (query.length > 100 ? '...' : ''),
+                params: params ? `${Array.isArray(params) ? params.length : 'object'} params` : 'no params'
+            });
+        }
+    }
+};
+
+/**
+ * Legacy console.log replacement - use logger.debug instead
+ * @deprecated Use logger.debug() instead
+ */
+export const log = logger.debug;