@joystick.js/db-canary 0.0.0-canary.2209

package/src/server/lib/operations/admin.js

@@ -0,0 +1,808 @@
+/**
+ * @fileoverview Comprehensive admin operations for database management, monitoring, and maintenance.
+ * 
+ * Provides extensive administrative functionality including statistics collection, collection management,
+ * document operations, backup/restore, replication management, index operations, and performance monitoring.
+ * Supports both legacy and modern admin operation formats with comprehensive error handling.
+ */
+
+import { get_database } from '../query_engine.js';
+import { get_settings } from '../load_settings.js';
+import { get_write_queue } from '../write_queue.js';
+import { get_auth_stats } from '../auth_manager.js';
+import { 
+  get_query_statistics,
+  get_auto_index_statistics,
+  force_index_evaluation,
+  remove_automatic_indexes
+} from '../auto_index_manager.js';
+import {
+  create_index,
+  drop_index,
+  get_indexes
+} from '../index_manager.js';
+import { 
+  test_s3_connection,
+  create_backup,
+  list_backups,
+  restore_backup,
+  cleanup_old_backups
+} from '../backup_manager.js';
+import { get_replication_manager } from '../replication_manager.js';
+import { get_write_forwarder } from '../write_forwarder.js';
+import create_logger from '../logger.js';
+import { performance_monitor } from '../performance_monitor.js';
+
+const { create_context_logger } = create_logger('admin');
+
+/**
+ * Gets comprehensive server and database statistics.
+ * @returns {Object} Enhanced statistics including server, database, and performance metrics
+ * @throws {Error} When stats collection fails
+ */
+const get_enhanced_stats = () => {
+  const log = create_context_logger();
+  
+  try {
+    const db = get_database();
+    
+    // Handle settings gracefully - use defaults if not loaded
+    let settings;
+    try {
+      settings = get_settings();
+    } catch (settings_error) {
+      settings = { port: 1983 };
+    }
+    
+    // Safely get database stats
+    let db_stats = {};
+    try {
+      const raw_stats = db.getStats ? db.getStats() : {};
+      db_stats = {
+        pageSize: raw_stats.pageSize || 0,
+        treeDepth: raw_stats.treeDepth || 0,
+        treeBranchPages: raw_stats.treeBranchPages || 0,
+        treeLeafPages: raw_stats.treeLeafPages || 0,
+        entryCount: raw_stats.entryCount || 0,
+        mapSize: raw_stats.mapSize || 0,
+        lastPageNumber: raw_stats.lastPageNumber || 0
+      };
+    } catch (stats_error) {
+      db_stats = { error: 'Could not retrieve database stats' };
+    }
+    
+    // Count collections and documents safely
+    const collections = {};
+    let total_documents = 0;
+    
+    try {
+      for (const { key } of db.getRange()) {
+        if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
+          const collection_name = key.split(':')[0];
+          collections[collection_name] = (collections[collection_name] || 0) + 1;
+          total_documents++;
+        }
+      }
+    } catch (range_error) {
+      log.warn('Could not iterate database range for stats', { error: range_error.message });
+    }
+    
+    // Calculate memory usage percentage
+    const memory_usage = process.memoryUsage();
+    const memory_usage_mb = {
+      rss: Math.round(memory_usage.rss / 1024 / 1024),
+      heapTotal: Math.round(memory_usage.heapTotal / 1024 / 1024),
+      heapUsed: Math.round(memory_usage.heapUsed / 1024 / 1024),
+      external: Math.round(memory_usage.external / 1024 / 1024)
+    };
+    
+    // Calculate database size percentage
+    const map_size_usage_percent = db_stats.mapSize > 0 
+      ? Math.round((db_stats.lastPageNumber * db_stats.pageSize / db_stats.mapSize) * 100)
+      : 0;
+    
+    return {
+      server: {
+        uptime: Math.floor(process.uptime()),
+        uptime_formatted: format_uptime(process.uptime()),
+        memory_usage: memory_usage_mb,
+        memory_usage_raw: memory_usage,
+        node_version: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        pid: process.pid,
+        cpu_usage: process.cpuUsage()
+      },
+      database: {
+        total_documents,
+        total_collections: Object.keys(collections).length,
+        collections,
+        stats: db_stats,
+        map_size_usage_percent,
+        disk_usage: {
+          map_size_mb: Math.round((db_stats.mapSize || 0) / 1024 / 1024),
+          used_space_mb: Math.round(((db_stats.lastPageNumber || 0) * (db_stats.pageSize || 0)) / 1024 / 1024)
+        }
+      },
+      performance: {
+        ops_per_second: calculate_ops_per_second(),
+        avg_response_time_ms: calculate_avg_response_time()
+      }
+    };
+  } catch (error) {
+    log.error('Failed to get enhanced stats', { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Formats uptime seconds into human-readable string.
+ * @param {number} seconds - Uptime in seconds
+ * @returns {string} Formatted uptime string (e.g., "2d 3h 45m 12s")
+ */
+const format_uptime = (seconds) => {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+  
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m ${secs}s`;
+  } else if (hours > 0) {
+    return `${hours}h ${minutes}m ${secs}s`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${secs}s`;
+  } else {
+    return `${secs}s`;
+  }
+};
+
+// Simple performance tracking (in production, this would be more sophisticated)
+let operation_count = 0;
+let total_response_time = 0;
+let start_time = Date.now();
+
+/**
+ * Calculates operations per second based on tracked operations.
+ * @returns {number} Operations per second
+ */
+const calculate_ops_per_second = () => {
+  const elapsed_seconds = (Date.now() - start_time) / 1000;
+  return elapsed_seconds > 0 ? Math.round(operation_count / elapsed_seconds) : 0;
+};
+
+/**
+ * Calculates average response time based on tracked operations.
+ * @returns {number} Average response time in milliseconds
+ */
+const calculate_avg_response_time = () => {
+  return operation_count > 0 ? Math.round(total_response_time / operation_count) : 0;
+};
+
+/**
+ * Tracks an operation for performance monitoring.
+ * @param {number} duration_ms - Operation duration in milliseconds
+ */
+export const track_operation = (duration_ms) => {
+  operation_count++;
+  total_response_time += duration_ms;
+};
+
+/**
+ * Lists all collections in the database with metadata.
+ * @param {string} [database_name='default'] - Database name to list collections from
+ * @returns {Object} Object containing collections array, total counts
+ * @throws {Error} When collection listing fails
+ */
+const list_collections = (database_name = 'default') => {
+  const log = create_context_logger();
+  
+  try {
+    const db = get_database();
+    const collections_map = {};
+    let total_documents = 0;
+    
+    // Look for database:collection:document_id format
+    try {
+      for (const { key } of db.getRange()) {
+        if (typeof key === 'string' && key.includes(':') && !key.startsWith('_')) {
+          const parts = key.split(':');
+          if (parts.length >= 3) {
+            const key_database = parts[0];
+            const collection_name = parts[1];
+            
+            // Only count collections from the specified database
+            if (key_database === database_name) {
+              if (!collections_map[collection_name]) {
+                collections_map[collection_name] = {
+                  name: collection_name,
+                  document_count: 0,
+                  indexes: [],
+                  estimated_size_bytes: 0
+                };
+              }
+              collections_map[collection_name].document_count++;
+              total_documents++;
+            }
+          }
+        }
+      }
+    } catch (range_error) {
+      log.warn('Could not iterate database range for collections', { error: range_error.message });
+      
+      // Fallback: try to find collections by checking for database-specific patterns
+      const potential_collections = [
+        'admin_test', 'test_collection', 'queue_test', 'users', 'products', 
+        'orders', 'sessions', 'logs', 'analytics', 'settings', 'another_collection',
+        'list_test', 'pagination_test', 'get_test', 'query_test', 'admin_insert_test',
+        'admin_update_test', 'admin_delete_test'
+      ];
+      
+      for (const collection_name of potential_collections) {
+        try {
+          // Check if this collection has any documents in the specified database
+          const prefix = `${database_name}:${collection_name}:`;
+          const range = db.getRange({ start: prefix, end: prefix + '\xFF' });
+          
+          let document_count = 0;
+          for (const entry of range) {
+            document_count++;
+            total_documents++;
+          }
+          
+          if (document_count > 0) {
+            collections_map[collection_name] = {
+              name: collection_name,
+              document_count,
+              indexes: [],
+              estimated_size_bytes: document_count * 100 // Rough estimate
+            };
+          }
+        } catch (collection_error) {
+          // Skip collections that can't be accessed
+          continue;
+        }
+      }
+    }
+    
+    // Get index information for each collection safely
+    try {
+      const index_prefix = `index:${database_name}:`;
+      const index_range = db.getRange({ start: index_prefix, end: index_prefix + '\xFF' });
+      for (const { key, value } of index_range) {
+        if (typeof key === 'string' && key.startsWith(index_prefix)) {
+          const remaining_key = key.substring(index_prefix.length);
+          const collection_name = remaining_key.split(':')[0];
+          if (collections_map[collection_name]) {
+            if (!collections_map[collection_name].indexes.includes(remaining_key.split(':')[1])) {
+              collections_map[collection_name].indexes.push(remaining_key.split(':')[1]);
+            }
+          }
+        }
+      }
+    } catch (index_range_error) {
+      log.warn('Could not iterate index range', { error: index_range_error.message });
+    }
+    
+    const collections_array = Object.values(collections_map);
+    
+    return {
+      collections: collections_array,
+      total_collections: collections_array.length,
+      total_documents
+    };
+  } catch (error) {
+    log.error('Failed to list collections', { error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Lists documents in a collection with pagination and sorting.
+ * @param {string} collection - Collection name
+ * @param {Object} [options={}] - List options
+ * @param {number} [options.limit=50] - Maximum documents to return
+ * @param {number} [options.skip=0] - Number of documents to skip
+ * @param {string} [options.sort_field] - Field to sort by
+ * @param {string} [options.sort_order='asc'] - Sort order ('asc' or 'desc')
+ * @param {string} [options.database='default'] - Database name
+ * @returns {Object} Object containing documents array and pagination info
+ * @throws {Error} When collection name is missing or listing fails
+ */
+const list_documents = (collection, options = {}) => {
+  const log = create_context_logger();
+  
+  if (!collection) {
+    throw new Error('Collection name is required');
+  }
+  
+  try {
+    const db = get_database();
+    const { limit = 50, skip = 0, sort_field, sort_order = 'asc', database = 'default' } = options;
+    
+    const documents = [];
+    const prefix = `${database}:${collection}:`;
+    let count = 0;
+    let skipped = 0;
+    
+    for (const { key, value } of db.getRange({ start: prefix, end: prefix + '\xFF' })) {
+      if (typeof key === 'string' && key.startsWith(prefix)) {
+        if (skipped < skip) {
+          skipped++;
+          continue;
+        }
+        
+        if (count >= limit) {
+          break;
+        }
+        
+        try {
+          const document = JSON.parse(value);
+          const document_id = key.substring(prefix.length);
+          documents.push({ _id: document_id, ...document });
+          count++;
+        } catch (parse_error) {
+          log.warn('Could not parse document', { 
+            collection, 
+            key, 
+            error: parse_error.message 
+          });
+        }
+      }
+    }
+    
+    // Simple sorting if requested
+    if (sort_field && documents.length > 0) {
+      documents.sort((a, b) => {
+        const a_val = a[sort_field];
+        const b_val = b[sort_field];
+        
+        if (sort_order === 'desc') {
+          return b_val > a_val ? 1 : b_val < a_val ? -1 : 0;
+        } else {
+          return a_val > b_val ? 1 : a_val < b_val ? -1 : 0;
+        }
+      });
+    }
+    
+    return {
+      collection,
+      documents,
+      count: documents.length,
+      skip,
+      limit,
+      has_more: count === limit
+    };
+  } catch (error) {
+    log.error('Failed to list documents', { collection, error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Gets a specific document by ID from a collection.
+ * @param {string} collection - Collection name
+ * @param {string} document_id - Document ID
+ * @param {string} [database='default'] - Database name
+ * @returns {Object} Object containing found status and document data
+ * @throws {Error} When collection name or document ID is missing
+ */
+const get_document = (collection, document_id, database = 'default') => {
+  const log = create_context_logger();
+  
+  if (!collection || !document_id) {
+    throw new Error('Collection name and document ID are required');
+  }
+  
+  try {
+    const db = get_database();
+    const key = `${database}:${collection}:${document_id}`;
+    const value = db.get(key);
+    
+    if (!value) {
+      return { found: false, collection, document_id };
+    }
+    
+    const document = JSON.parse(value);
+    return {
+      found: true,
+      collection,
+      document_id,
+      document: { _id: document_id, ...document }
+    };
+  } catch (error) {
+    log.error('Failed to get document', { collection, document_id, error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Queries documents in a collection with filtering and pagination.
+ * @param {string} collection - Collection name
+ * @param {Object} [filter={}] - Query filter with MongoDB-style operators
+ * @param {Object} [options={}] - Query options
+ * @param {number} [options.limit=100] - Maximum documents to return
+ * @param {number} [options.skip=0] - Number of documents to skip
+ * @param {string} [options.database='default'] - Database name
+ * @returns {Object} Object containing matching documents and query metadata
+ * @throws {Error} When collection name is missing or query fails
+ */
+const query_documents = (collection, filter = {}, options = {}) => {
+  const log = create_context_logger();
+  
+  if (!collection) {
+    throw new Error('Collection name is required');
+  }
+  
+  try {
+    const db = get_database();
+    const { limit = 100, skip = 0, database = 'default' } = options;
+    
+    const documents = [];
+    const prefix = `${database}:${collection}:`;
+    let count = 0;
+    let skipped = 0;
+    let total_examined = 0;
+    
+    for (const { key, value } of db.getRange({ start: prefix, end: prefix + '\xFF' })) {
+      if (typeof key === 'string' && key.startsWith(prefix)) {
+        total_examined++;
+        
+        try {
+          const document = JSON.parse(value);
+          const document_id = key.substring(prefix.length);
+          const full_document = { _id: document_id, ...document };
+          
+          // Simple filter matching
+          const matches = Object.keys(filter).every(field => {
+            const filter_value = filter[field];
+            const doc_value = full_document[field];
+            
+            if (typeof filter_value === 'object' && filter_value !== null) {
+              // Handle operators like { $gt: 5 }, { $regex: "pattern" }
+              return Object.keys(filter_value).every(operator => {
+                const op_value = filter_value[operator];
+                switch (operator) {
+                  case '$gt': return doc_value > op_value;
+                  case '$gte': return doc_value >= op_value;
+                  case '$lt': return doc_value < op_value;
+                  case '$lte': return doc_value <= op_value;
+                  case '$ne': return doc_value !== op_value;
+                  case '$in': return Array.isArray(op_value) && op_value.includes(doc_value);
+                  case '$regex': return new RegExp(op_value).test(String(doc_value));
+                  default: return doc_value === filter_value;
+                }
+              });
+            } else {
+              return doc_value === filter_value;
+            }
+          });
+          
+          if (matches) {
+            if (skipped < skip) {
+              skipped++;
+              continue;
+            }
+            
+            if (count >= limit) {
+              break;
+            }
+            
+            documents.push(full_document);
+            count++;
+          }
+        } catch (parse_error) {
+          log.warn('Could not parse document during query', { 
+            collection, 
+            key, 
+            error: parse_error.message 
+          });
+        }
+      }
+    }
+    
+    return {
+      collection,
+      filter,
+      documents,
+      count: documents.length,
+      total_examined,
+      skip,
+      limit,
+      has_more: count === limit
+    };
+  } catch (error) {
+    log.error('Failed to query documents', { collection, filter, error: error.message });
+    throw error;
+  }
+};
+
+/**
+ * Inserts a document via admin interface (delegates to insert_one operation).
+ * @param {string} database_name - Database name
+ * @param {string} collection - Collection name
+ * @param {Object} document - Document to insert
+ * @param {Object} [options={}] - Insert options
+ * @returns {Promise<Object>} Insert result
+ */
+const insert_document = async (database_name, collection, document, options = {}) => {
+  const insert_one_module = await import('./insert_one.js');
+  return await insert_one_module.default(database_name, collection, document, options);
+};
+
+/**
+ * Updates a document via admin interface (delegates to update_one operation).
+ * @param {string} database_name - Database name
+ * @param {string} collection - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {Object} update - Update operations
+ * @param {Object} [options={}] - Update options
+ * @returns {Promise<Object>} Update result
+ */
+const update_document = async (database_name, collection, filter, update, options = {}) => {
+  const update_one_module = await import('./update_one.js');
+  return await update_one_module.default(database_name, collection, filter, update, options);
+};
+
+/**
+ * Deletes a document via admin interface (delegates to delete_one operation).
+ * @param {string} database_name - Database name
+ * @param {string} collection - Collection name
+ * @param {Object} filter - Filter criteria
+ * @param {Object} [options={}] - Delete options
+ * @returns {Promise<Object>} Delete result
+ */
+const delete_document = async (database_name, collection, filter, options = {}) => {
+  const delete_one_module = await import('./delete_one.js');
+  return await delete_one_module.default(database_name, collection, filter, options);
+};
+
+/**
+ * Main admin operation handler supporting various administrative actions.
+ * @param {string} admin_action - Admin action to perform
+ * @param {Object} [data={}] - Action-specific data
+ * @param {Object} connection_manager - Connection manager instance
+ * @param {Set} authenticated_clients - Set of authenticated client IDs
+ * @returns {Promise<Object>} Action result
+ * @throws {Error} When admin action fails
+ */
+export default async (admin_action, data = {}, connection_manager, authenticated_clients) => {
+  const log = create_context_logger();
+  const start_time = Date.now();
+  
+  try {
+    let result;
+    
+    switch (admin_action) {
+      case 'stats':
+        result = {
+          server: {
+            uptime: Math.floor(process.uptime()),
+            uptime_formatted: format_uptime(process.uptime()),
+            node_version: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            pid: process.pid
+          },
+          memory: performance_monitor.get_memory_stats(),
+          database: {
+            ...performance_monitor.get_database_stats(),
+            map_size_mb: Math.round((performance_monitor.get_database_stats()?.map_size || 0) / 1024 / 1024),
+            used_space_mb: Math.round((performance_monitor.get_database_stats()?.used_space || 0) / 1024 / 1024),
+            usage_percent: performance_monitor.get_database_stats()?.usage_percent || 0
+          },
+          performance: {
+            ops_per_second: calculate_ops_per_second(),
+            avg_response_time_ms: calculate_avg_response_time()
+          },
+          system: performance_monitor.get_system_stats(),
+          connections: connection_manager?.get_stats() || {},
+          write_queue: get_write_queue()?.get_stats() || {},
+          authentication: {
+            authenticated_clients: authenticated_clients?.size || 0,
+            ...get_auth_stats()
+          },
+          settings: (() => {
+            try {
+              const settings = get_settings();
+              return {
+                port: settings.port || 1983
+              };
+            } catch (error) {
+              return { port: 1983 };
+            }
+          })()
+        };
+        break;
+        
+      case 'list_collections':
+        result = list_collections();
+        break;
+        
+      case 'list_documents':
+        result = list_documents(data.collection, { 
+          limit: data.limit, 
+          skip: data.skip, 
+          sort_field: data.sort_field, 
+          sort_order: data.sort_order 
+        });
+        break;
+        
+      case 'get_document':
+        result = get_document(data.collection, data.document_id);
+        break;
+        
+      case 'query_documents':
+        result = query_documents(data.collection, data.filter, { 
+          limit: data.limit, 
+          skip: data.skip 
+        });
+        break;
+        
+      case 'insert_document':
+        result = await insert_document(data.database || 'default', data.collection, data.document, data.options);
+        break;
+        
+      case 'update_document':
+        // If document_id is provided, use it as a filter, otherwise use the provided filter
+        const final_update_filter = data.document_id ? { _id: data.document_id } : data.filter;
+        result = await update_document(data.database || 'default', data.collection, final_update_filter, data.update, data.options);
+        break;
+        
+      case 'delete_document':
+        // If document_id is provided, use it as a filter, otherwise use the provided filter
+        const final_delete_filter = data.document_id ? { _id: data.document_id } : data.filter;
+        result = await delete_document(data.database || 'default', data.collection, final_delete_filter, data.options);
+        break;
+        
+      case 'test_s3_connection':
+        result = await test_s3_connection();
+        break;
+        
+      case 'backup_now':
+        result = await create_backup();
+        break;
+        
+      case 'list_backups':
+        result = await list_backups();
+        break;
+        
+      case 'restore_backup':
+        if (!data.backup_filename) {
+          throw new Error('backup_filename is required for restore operation');
+        }
+        result = await restore_backup(data.backup_filename);
+        break;
+        
+      case 'cleanup_backups':
+        result = await cleanup_old_backups();
+        break;
+        
+      case 'get_auto_index_stats':
+        result = get_auto_index_statistics();
+        break;
+        
+      case 'get_query_stats':
+        result = get_query_statistics(data.collection);
+        break;
+        
+      case 'evaluate_auto_indexes':
+        result = await force_index_evaluation(data.collection);
+        break;
+        
+      case 'remove_auto_indexes':
+        if (!data.collection) {
+          throw new Error('collection is required for remove_auto_indexes operation');
+        }
+        result = await remove_automatic_indexes(data.collection, data.field_names);
+        break;
+        
+      case 'create_index':
+        if (!data.collection || !data.field) {
+          throw new Error('collection and field are required for create_index operation');
+        }
+        result = await create_index(data.database || 'default', data.collection, data.field, data.options);
+        break;
+        
+      case 'drop_index':
+        if (!data.collection || !data.field) {
+          throw new Error('collection and field are required for drop_index operation');
+        }
+        result = await drop_index(data.database || 'default', data.collection, data.field);
+        break;
+        
+      case 'get_indexes':
+        if (!data.collection) {
+          throw new Error('collection is required for get_indexes operation');
+        }
+        result = { indexes: get_indexes(data.database || 'default', data.collection) };
+        break;
+        
+      case 'get_replication_status':
+        const replication_manager = get_replication_manager();
+        result = replication_manager.get_replication_status();
+        break;
+        
+      case 'add_secondary':
+        if (!data.id || !data.ip || !data.port || !data.private_key) {
+          throw new Error('id, ip, port, and private_key are required for add_secondary operation');
+        }
+        const add_replication_manager = get_replication_manager();
+        result = await add_replication_manager.add_secondary({ 
+          id: data.id, 
+          ip: data.ip, 
+          port: data.port, 
+          private_key: data.private_key, 
+          enabled: true 
+        });
+        break;
+        
+      case 'remove_secondary':
+        if (!data.secondary_id) {
+          throw new Error('secondary_id is required for remove_secondary operation');
+        }
+        const remove_replication_manager = get_replication_manager();
+        result = remove_replication_manager.remove_secondary(data.secondary_id);
+        break;
+        
+      case 'sync_secondaries':
+        const sync_replication_manager = get_replication_manager();
+        result = await sync_replication_manager.sync_secondaries();
+        break;
+        
+      case 'get_secondary_health':
+        const health_replication_manager = get_replication_manager();
+        result = health_replication_manager.get_secondary_health();
+        break;
+        
+      case 'get_forwarder_status':
+        const write_forwarder = get_write_forwarder();
+        result = write_forwarder.get_forwarder_status();
+        break;
+        
+      default:
+        // Default admin action (backward compatibility)
+        result = {
+          ...get_enhanced_stats(),
+          connections: connection_manager?.get_stats() || {},
+          write_queue: get_write_queue()?.get_stats() || {},
+          authentication: {
+            authenticated_clients: authenticated_clients?.size || 0,
+            ...get_auth_stats()
+          },
+          settings: (() => {
+            try {
+              const settings = get_settings();
+              return {
+                port: settings.port || 1983
+              };
+            } catch (error) {
+              return { port: 1983 };
+            }
+          })()
+        };
+    }
+    
+    const duration_ms = Date.now() - start_time;
+    track_operation(duration_ms);
+    
+    log.info('Admin operation completed', {
+      admin_action: admin_action || 'default',
+      duration_ms,
+      status: 'success'
+    });
+    
+    return result;
+  } catch (error) {
+    const duration_ms = Date.now() - start_time;
+    
+    log.error('Admin operation failed', {
+      admin_action: admin_action || 'default',
+      duration_ms,
+      status: 'error',
+      error: error.message
+    });
+    
+    throw error;
+  }
+};