Comprehensive comparison for Database technology in Software Development applications

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

class BuildMetricsService {
  constructor(url, token, org, bucket) {
    this.influxDB = new InfluxDB({ url, token });
    this.org = org;
    this.bucket = bucket;
    this.writeApi = this.influxDB.getWriteApi(org, bucket, 'ms');
    this.queryApi = this.influxDB.getQueryApi(org);
    
    this.writeApi.useDefaultTags({ environment: process.env.NODE_ENV || 'development' });
  }

  async recordBuildMetrics(buildData) {
    try {
      const point = new Point('ci_build')
        .tag('project', buildData.project)
        .tag('branch', buildData.branch)
        .tag('status', buildData.status)
        .tag('builder', buildData.builder)
        .intField('duration_ms', buildData.durationMs)
        .intField('test_count', buildData.testCount)
        .intField('test_failures', buildData.testFailures)
        .floatField('code_coverage', buildData.codeCoverage)
        .intField('build_number', buildData.buildNumber)
        .stringField('commit_hash', buildData.commitHash)
        .timestamp(new Date());

      this.writeApi.writePoint(point);
      await this.writeApi.flush();
      
      console.log(`Build metrics recorded for ${buildData.project}:${buildData.buildNumber}`);
      return { success: true };
    } catch (error) {
      console.error('Error writing build metrics:', error);
      throw new Error(`Failed to record build metrics: ${error.message}`);
    }
  }

  async getAverageBuildTime(project, hours = 24) {
    const query = `
      from(bucket: "${this.bucket}")
        |> range(start: -${hours}h)
        |> filter(fn: (r) => r._measurement == "ci_build")
        |> filter(fn: (r) => r.project == "${project}")
        |> filter(fn: (r) => r._field == "duration_ms")
        |> mean()
    `;

    try {
      const result = await this.queryApi.collectRows(query);
      if (result.length === 0) {
        return null;
      }
      return result[0]._value;
    } catch (error) {
      console.error('Error querying build metrics:', error);
      throw new Error(`Failed to query average build time: ${error.message}`);
    }
  }

  async getFailureRate(project, days = 7) {
    const query = `
      from(bucket: "${this.bucket}")
        |> range(start: -${days}d)
        |> filter(fn: (r) => r._measurement == "ci_build")
        |> filter(fn: (r) => r.project == "${project}")
        |> filter(fn: (r) => r._field == "build_number")
        |> group(columns: ["status"])
        |> count()
    `;

    try {
      const results = await this.queryApi.collectRows(query);
      const total = results.reduce((sum, row) => sum + row._value, 0);
      const failed = results.find(r => r.status === 'failed')?._value || 0;
      
      return total > 0 ? (failed / total) * 100 : 0;
    } catch (error) {
      console.error('Error calculating failure rate:', error);
      throw new Error(`Failed to calculate failure rate: ${error.message}`);
    }
  }

  async cleanupOldMetrics(days = 90) {
    try {
      const deleteAPI = new DeleteAPI(this.influxDB);
      const start = new Date(0).toISOString();
      const stop = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
      
      await deleteAPI.postDelete({
        org: this.org,
        bucket: this.bucket,
        body: {
          start,
          stop,
          predicate: '_measurement="ci_build"'
        }
      });
      
      console.log(`Deleted metrics older than ${days} days`);
      return { success: true };
    } catch (error) {
      console.error('Error deleting old metrics:', error);
      throw new Error(`Failed to cleanup old metrics: ${error.message}`);
    }
  }

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

module.exports = BuildMetricsService;