Comprehensive comparison for Database technology in Software Development applications

const { InfluxDB, Point } = require('@influxdata/influxdb-client');
const { DeleteAPI } = require('@influxdata/influxdb-client-apis');

class ApplicationMetricsService {
  constructor(config) {
    this.url = config.url || 'http://localhost:8086';
    this.token = config.token;
    this.org = config.org;
    this.bucket = config.bucket || 'app_metrics';
    
    this.client = new InfluxDB({ url: this.url, token: this.token });
    this.writeApi = this.client.getWriteApi(this.org, this.bucket, 'ms');
    this.queryApi = this.client.getQueryApi(this.org);
    
    this.writeApi.useDefaultTags({ environment: config.environment || 'production' });
  }

  async trackAPIRequest(endpoint, method, statusCode, duration, userId = null) {
    try {
      const point = new Point('api_request')
        .tag('endpoint', endpoint)
        .tag('method', method)
        .tag('status_code', statusCode.toString())
        .intField('duration_ms', duration)
        .intField('count', 1);
      
      if (userId) {
        point.tag('user_id', userId);
      }
      
      this.writeApi.writePoint(point);
      await this.writeApi.flush();
      
      return { success: true };
    } catch (error) {
      console.error('Error writing API metrics to InfluxDB:', error);
      return { success: false, error: error.message };
    }
  }

  async trackDatabaseQuery(queryType, table, executionTime, rowsAffected) {
    try {
      const point = new Point('database_query')
        .tag('query_type', queryType)
        .tag('table', table)
        .intField('execution_time_ms', executionTime)
        .intField('rows_affected', rowsAffected);
      
      this.writeApi.writePoint(point);
      await this.writeApi.flush();
      
      return { success: true };
    } catch (error) {
      console.error('Error writing database metrics:', error);
      return { success: false, error: error.message };
    }
  }

  async getAPIPerformanceStats(endpoint, timeRange = '-1h') {
    try {
      const query = `
        from(bucket: "${this.bucket}")
          |> range(start: ${timeRange})
          |> filter(fn: (r) => r._measurement == "api_request")
          |> filter(fn: (r) => r.endpoint == "${endpoint}")
          |> filter(fn: (r) => r._field == "duration_ms")
          |> aggregateWindow(every: 5m, fn: mean, createEmpty: false)
      `;
      
      const results = [];
      
      return new Promise((resolve, reject) => {
        this.queryApi.queryRows(query, {
          next(row, tableMeta) {
            const result = tableMeta.toObject(row);
            results.push({
              time: result._time,
              avgDuration: result._value,
              endpoint: result.endpoint
            });
          },
          error(error) {
            console.error('Query error:', error);
            reject(error);
          },
          complete() {
            resolve(results);
          }
        });
      });
    } catch (error) {
      console.error('Error querying API performance:', error);
      throw error;
    }
  }

  async getErrorRate(timeRange = '-1h') {
    try {
      const query = `
        from(bucket: "${this.bucket}")
          |> range(start: ${timeRange})
          |> filter(fn: (r) => r._measurement == "api_request")
          |> filter(fn: (r) => r._field == "count")
          |> group(columns: ["status_code"])
          |> sum()
      `;
      
      const results = [];
      
      return new Promise((resolve, reject) => {
        this.queryApi.queryRows(query, {
          next(row, tableMeta) {
            const result = tableMeta.toObject(row);
            results.push({
              statusCode: result.status_code,
              count: result._value
            });
          },
          error(error) {
            reject(error);
          },
          complete() {
            const totalRequests = results.reduce((sum, r) => sum + r.count, 0);
            const errorRequests = results
              .filter(r => parseInt(r.statusCode) >= 400)
              .reduce((sum, r) => sum + r.count, 0);
            
            resolve({
              totalRequests,
              errorRequests,
              errorRate: totalRequests > 0 ? (errorRequests / totalRequests) * 100 : 0,
              breakdown: results
            });
          }
        });
      });
    } catch (error) {
      console.error('Error calculating error rate:', error);
      throw error;
    }
  }

  async close() {
    try {
      await this.writeApi.close();
      console.log('InfluxDB connection closed successfully');
    } catch (error) {
      console.error('Error closing InfluxDB connection:', error);
    }
  }
}

module.exports = ApplicationMetricsService;