@hiiretail/gcp-infra-cli 0.76.0 → 0.76.1

package/generators/resources/monitoring/handle-yaml.js

@@ -0,0 +1,28 @@
+const ejs = require('ejs');
+
+const handleAlerts = (alerts, templates, answers) => {
+  const template = templates[`${answers.alertResource}`][`${answers.alert}`];
+  const newAlert = JSON.parse(ejs.render(JSON.stringify(template), answers));
+
+  alerts.push(newAlert);
+  return alerts;
+};
+
+const handleSlos = (slos, templates, answers) => {
+  const template = templates[`${answers.sli}`];
+  const newSLO = JSON.parse(ejs.render(JSON.stringify(template), answers));
+
+  if (answers.burnRateAlert === 'no') newSLO.alert = {};
+
+  slos.push(newSLO);
+  return slos;
+};
+
+const handleUptimeChecks = (slos, templates, answers) => {
+  const newCheck = JSON.parse(ejs.render(JSON.stringify(templates), answers));
+
+  slos.push(newCheck);
+  return slos;
+};
+
+module.exports = { handleAlerts, handleSlos, handleUptimeChecks };

package/generators/resources/monitoring/index.js

@@ -4,12 +4,12 @@ const fs = require('fs');
 const yaml = require('js-yaml');
 const BaseGenerator = require('../../../src/BaseGenerator');
 const { required } = require('../../../src/validators');
-const validator = require('./validate');
-const handleSlosFile = require('./handle-slos');
-const handleUptimeFile = require('./handle-uptime');
-const handleAlerts = require('./handle-alerts');
+const validate = require('./validate');
+const { handleSlos, handleAlerts, handleUptimeChecks } = require('./handle-yaml');
 
+const uptimeCheckTemplates = yaml.load(fs.readFileSync(`${__dirname}/templates/uptime-checks/uptime-checks.yaml`));
 const alertTemplates = yaml.load(fs.readFileSync(`${__dirname}/templates/alerts/alerts.yaml`));
+const sloTemplates = yaml.load(fs.readFileSync(`${__dirname}/templates/slos/slos.yaml`));
 
 module.exports = class extends BaseGenerator {
   async prompting() {
@@ -37,7 +37,7 @@ module.exports = class extends BaseGenerator {
         type: 'input',
         name: 'systemName',
         message: 'Please provide three-letter system name as defined in Styra (example: sre, ptf, sda, che, pnp, iam...)',
-        validate: required && validator.systemName,
+        validate: required && validate.systemName,
       },
       {
         when: (response) => ['slos', 'uptime-checks'].includes(response.monitoringResource) || response.alertResource === 'cloud_run',
@@ -51,7 +51,7 @@ module.exports = class extends BaseGenerator {
         type: 'input',
         name: 'runbookLink',
         message: 'Please provide the full URL to your runbook in confluence (Leave empty if none)',
-        validate: required && validator.url,
+        validate: required && validate.url,
       },
       {
         when: (response) => response.alertResource === 'cloud_scheduler',
@@ -65,28 +65,28 @@ module.exports = class extends BaseGenerator {
         type: 'input',
         name: 'databaseId',
         message: 'Please provide the "database id"',
-        validate: required && validator.databaseId,
+        validate: required && validate.databaseId,
       },
       {
         when: (response) => response.alertResource === 'memorystore',
         type: 'input',
         name: 'instanceId',
         message: 'Please provide the "instance id"',
-        validate: required && validator.instanceID,
+        validate: required && validate.instanceID,
       },
       {
         when: (response) => response.alertResource === 'pub_sub',
         type: 'input',
         name: 'subscriptionId',
         message: 'Please provide the "subscription id"',
-        validate: required && validator.pubSubSubscription,
+        validate: required && validate.pubSubSubscription,
       },
       {
         when: (response) => response.monitoringResource === 'uptime-checks',
         type: 'input',
         name: 'hostname',
         message: 'Please provide the base hostname of the service (example: my-service.retailsvc.com)',
-        validate: required && validator.validHostname,
+        validate: required && validate.hostName,
       },
       {
         when: (response) => response.monitoringResource === 'uptime-checks',
@@ -101,132 +101,70 @@ module.exports = class extends BaseGenerator {
         type: 'list',
         name: 'sli',
         message: 'Please select the SLI',
-        choices: ['availability', 'error-rate', 'latency'],
+        choices: Object.keys(sloTemplates),
+      },
+      {
+        when: (response) => response.monitoringResource === 'slos' && response.sli === 'availability',
+        type: 'input',
+        name: 'uptimeCheckId',
+        message: 'Please provide the "Uptime Check ID" (NOTE: The "Uptime check" needs to have been created first in order to fetch the ID)',
+        validate: required,
       },
       {
         when: (response) => response.monitoringResource === 'slos',
         type: 'list',
-        name: 'burnRateAlerts',
+        name: 'burnRateAlert',
         message: 'Please select yes if you want to have burn-rate alerts included',
         default: 'yes',
         choices: ['yes', 'no'],
       },
-      {
-        when: (response) => response.monitoringResource === 'slos' && response.sli === 'availability',
-        type: 'confirm',
-        name: 'info',
-        message: 'WARNING: Make sure an uptime check has been created BEFORE continuing with the creation of this SLO.',
-      },
     ]);
   }
 
   async writing() {
-    const {
-      monitoringResource,
-      serviceName,
-      hostname,
-      sli,
-      systemName,
-      burnRateAlerts,
-    } = this.answers;
+    const { monitoringResource, serviceName } = this.answers;
+    const resourceDir = path.join(process.cwd(), 'infra', 'prod', 'monitoring', monitoringResource);
 
-    const resourcePath = path.join(process.cwd(), 'infra', 'prod', 'monitoring', monitoringResource);
+    const copyTemplate = (resource, resourcePath, yamlPath) => {
+      if (!fs.existsSync(resourcePath)) fs.mkdirSync(resourcePath, { recursive: true });
+      if (!fs.existsSync(yamlPath)) fs.writeFileSync(yamlPath, '');
+      if (!fs.existsSync(`${path}/terragrunt.hcl`)) {
+        this.fs.copyTpl(
+          this.templatePath(`${resource}/terragrunt.hcl`),
+          this.destinationPath(`${resourcePath}/terragrunt.hcl`),
+          this.answers,
+        );
+      }
+    };
 
     if (monitoringResource === 'uptime-checks') {
-      if (!fs.existsSync(resourcePath)) {
-        fs.mkdirSync(resourcePath, { recursive: true });
-      }
+      const yamlPath = `${resourceDir}/uptime-checks.yaml`;
 
-      const uptimeYamlFile = `${resourcePath}/uptime-checks.yaml`;
-      if (!fs.existsSync(uptimeYamlFile)) {
-        this.copyDir(
-          'uptime-checks',
-          resourcePath,
-          {
-            ...this.answers,
-            serviceName,
-            hostname,
-            systemName,
-          },
-        );
-      } else {
-        await handleUptimeFile(this.answers, uptimeYamlFile);
-      }
+      copyTemplate('uptime-checks', resourceDir, yamlPath);
+
+      const oldYaml = yaml.load(fs.readFileSync(yamlPath, 'utf8')) || [];
+      const newYaml = await handleUptimeChecks(oldYaml, uptimeCheckTemplates, this.answers);
+
+      fs.writeFileSync(yamlPath, yaml.dump(newYaml));
     }
 
     if (monitoringResource === 'slos') {
-      const serviceFolderName = serviceName.replace(/ /g, '-').toLowerCase();
-      const serviceDir = path.join(process.cwd(), 'infra', 'prod', 'monitoring', monitoringResource, serviceFolderName);
-      const fileContainsFilter = (fileName, str) => {
-        const contents = fs.readFileSync(fileName, 'utf-8');
-        const result = contents.includes(str);
-        return result;
-      };
-
-      if (!fs.existsSync(serviceDir)) {
-        fs.mkdirSync(serviceDir, { recursive: true });
-      }
+      const service = serviceName.replace(/ /g, '-').toLowerCase();
+      const servicePath = path.join(process.cwd(), 'infra', 'prod', 'monitoring', monitoringResource, service);
+      const yamlPath = `${servicePath}/slos.yaml`;
 
-      if (fs.existsSync(`${serviceDir}/terragrunt.hcl`)) {
-        if (fileContainsFilter(`${serviceDir}/terragrunt.hcl`, 'metric_filter') === false) {
-          this.fs.copyTpl(
-            this.templatePath('slos/terragrunt.hcl'),
-            this.destinationPath(`${serviceDir}/terragrunt.hcl`),
-            {
-              ...this.answers,
-              monitoringResource,
-              serviceName,
-              systemName,
-              burnRateAlerts,
-            },
-          );
-        }
-      } else {
-        this.fs.copyTpl(
-          this.templatePath('slos/terragrunt.hcl'),
-          this.destinationPath(`${serviceDir}/terragrunt.hcl`),
-          {
-            ...this.answers,
-            monitoringResource,
-            serviceName,
-            systemName,
-            burnRateAlerts,
-          },
-        );
-      }
+      copyTemplate('slos', servicePath, yamlPath);
 
-      const sloYamlFile = `${serviceDir}/slos.yaml`;
-      if (!fs.existsSync(sloYamlFile)) {
-        this.fs.copyTpl(
-          this.templatePath('slos/slos.yaml'),
-          this.destinationPath(sloYamlFile),
-          {
-            ...this.answers,
-            monitoringResource,
-            serviceName,
-            systemName,
-            sli,
-            burnRateAlerts,
-          },
-        );
-      } else {
-        await handleSlosFile(this.answers, sloYamlFile);
-      }
+      const oldYaml = yaml.load(fs.readFileSync(yamlPath, 'utf8')) || [];
+      const newYaml = await handleSlos(oldYaml, sloTemplates, this.answers);
+
+      fs.writeFileSync(yamlPath, yaml.dump(newYaml));
     }
 
     if (monitoringResource === 'alerts') {
-      const yamlPath = `${resourcePath}/alerts.yaml`;
-      const terraPath = `${resourcePath}/terragrunt.hcl`;
-      if (!fs.existsSync(resourcePath)) fs.mkdirSync(resourcePath, { recursive: true });
-      if (!fs.existsSync(yamlPath)) fs.writeFileSync(yamlPath, '');
+      const yamlPath = `${resourceDir}/alerts.yaml`;
 
-      if (!fs.existsSync(terraPath)) {
-        this.fs.copyTpl(
-          this.templatePath('alerts/terragrunt.hcl'),
-          this.destinationPath(terraPath),
-          this.answers,
-        );
-      }
+      copyTemplate('alerts', resourceDir, yamlPath);
 
       const oldYaml = yaml.load(fs.readFileSync(yamlPath, 'utf8')) || [];
       const newYaml = await handleAlerts(oldYaml, alertTemplates, this.answers);

package/generators/resources/monitoring/templates/alerts/terragrunt.hcl

@@ -23,11 +23,12 @@ locals {
 
 # These are the variables we have to pass in to use the module specified in the terragrunt configuration above
 inputs = {
-  monitoring_project_id   = local.project_vars.locals.monitoring_project_id,
+  monitoring_project_id   = lookup(local.project_vars.locals, "monitoring_project_id", local.project_vars.locals.tribe_project_id),
   notification_channels   = dependency.notification_channels.outputs.notification_channels,
   policies                = yamldecode(file("${get_terragrunt_dir()}/alerts.yaml")),
   user_labels             = {
-    cc   = local.common_vars.locals.cost_center
-    clan = local.common_vars.locals.clan_name
+    cc                = local.common_vars.locals.cost_center
+    clan              = local.common_vars.locals.clan_name
+    jira_project_key  = lookup(local.project_vars.locals, "jira_project_key", null)
   },
 }

package/generators/resources/monitoring/templates/slos/slos.yaml

@@ -1,35 +1,41 @@
-<% if (sli === 'latency') { %>- display_name: Month - Latency
-  slo_id: month-latency
-  goal: 0.95
-  calendar_period: MONTH
-  type: request_based_sli
-  method: distribution_cut
-  metric_filter: |-
-    metric.type="knative.dev/serving/revision/request_latencies"
-    resource.type="knative_revision"
-    resource.labels.service_name="<%-serviceName%>"
-  range_min: 0
-  range_max: 100<% if (burnRateAlerts === 'no') { %>
-  alert: {}<% } %><% } %><% if (sli === 'availability') { %>- display_name: Month - Availability
+availability:
+  display_name: Month - Availability
   slo_id: month-availability
   goal: 0.998
   calendar_period: MONTH
   type: windows_based_sli
   method: boolean_filter
-  window_period: 60s<% if (burnRateAlerts === 'no') { %>
-  alert: {}<% } %><% } %><% if (sli === 'error-rate') { %>- display_name: Month - Error rate
+  window_period: 60s
+  metric_filter: |
+    metric.type="monitoring.googleapis.com/uptime_check/check_passed"
+    resource.type="uptime_url"
+    metric.labels.check_id="<%-uptimeCheckId%>"
+error-rate:
+  display_name: Month - Error rate
   slo_id: month-error-rate
   goal: 0.999
   calendar_period: MONTH
   type: request_based_sli
   method: good_total_ratio
-  bad_service_filter: |-
+  bad_service_filter: |
     metric.type="knative.dev/serving/revision/request_count"
     resource.type="knative_revision"
     metric.labels.response_code_class="5xx"
     resource.labels.service_name="<%-serviceName%>"
-  total_service_filter: |-
+  total_service_filter: |
     metric.type="knative.dev/serving/revision/request_count"
     resource.type="knative_revision"
-    resource.labels.service_name="<%-serviceName%>"<% if (burnRateAlerts === 'no') { %>
-  alert: {}<% } %><% } %>
+    resource.labels.service_name="<%-serviceName%>"
+latency:
+  display_name: Month - Latency
+  slo_id: month-latency
+  goal: 0.95
+  calendar_period: MONTH
+  type: request_based_sli
+  method: distribution_cut
+  range_min: 0
+  range_max: 100
+  metric_filter: |
+    metric.type="knative.dev/serving/revision/request_latencies"
+    resource.type="knative_revision"
+    resource.labels.service_name="<%-serviceName%>"

package/generators/resources/monitoring/templates/slos/terragrunt.hcl

@@ -9,13 +9,6 @@ include {
   path = find_in_parent_folders("terragrunt_root.hcl")
 }
 
-dependency "uptimecheck_id" {
-  config_path  = "../../uptime-checks"
-  mock_outputs = {
-    uptime_check_ids = ["dummy-id"]
-  }
-}
-
 locals {
   project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
 }
@@ -25,13 +18,8 @@ inputs = merge(
   local.project_vars.locals,
   {
     service_name            = "<%-systemName%>.<%-serviceName%>"
+    monitoring_project_id   = lookup(local.project_vars.locals, "monitoring_project_id", local.project_vars.locals.tribe_project_id),
     slos                    = yamldecode(file("${get_terragrunt_dir()}/slos.yaml")),
-    telemetry_resource_name = "//container.googleapis.com/projects/${local.project_vars.locals.monitoring_project_id}/locations/europe-west1/clusters/k8s-cluster/k8s/namespaces/<%-serviceName%>"
-    <% if (sli === 'availability') { %>
-    metric_filter = {
-      "metric.type"            = "monitoring.googleapis.com/uptime_check/check_passed"
-      "resource.type"          = "uptime_url"
-      "metric.labels.check_id" = dependency.uptimecheck_id.outputs.uptime_check_ids["<%-systemName%>.<%-serviceName%>"]
-    }<% } %>
+    telemetry_resource_name = "//container.googleapis.com/projects/${lookup(local.project_vars.locals, "monitoring_project_id", local.project_vars.locals.tribe_project_id)}/locations/europe-west1/clusters/k8s-cluster/k8s/namespaces/<%-serviceName%>"
   }
 )

package/generators/resources/monitoring/templates/uptime-checks/terragrunt.hcl

@@ -26,11 +26,13 @@ inputs = merge(
   local.project_vars.locals,
   local.common_vars.locals,
   {
-    notification_channels = dependency.notification_channels.outputs.notification_channels
-    uptime_checks         = yamldecode(file("${get_terragrunt_dir()}/uptime-checks.yaml")),
-    labels                = {
-      clan = local.common_vars.locals.clan_name
-      cc   = local.common_vars.locals.cost_center
+    monitoring_project_id   = lookup(local.project_vars.locals, "monitoring_project_id", local.project_vars.locals.tribe_project_id),
+    notification_channels   = dependency.notification_channels.outputs.notification_channels
+    uptime_checks           = yamldecode(file("${get_terragrunt_dir()}/uptime-checks.yaml")),
+    labels                  = {
+      clan              = local.common_vars.locals.clan_name
+      cc                = local.common_vars.locals.cost_center
+      jira_project_key  = lookup(local.project_vars.locals, "jira_project_key", null)
     }
   }
 )

package/generators/resources/monitoring/templates/uptime-checks/uptime-checks.yaml

@@ -1,3 +1,3 @@
-- service_name: <%-systemName%>.<%-serviceName%>
-  hostname: <%-hostname%>
-  path: <%-path%>
+service_name: <%-systemName%>.<%-serviceName%>
+hostname: <%-hostname%>
+path: <%-path%>

package/generators/resources/monitoring/validate.js

@@ -1,40 +1,36 @@
-const validator = {};
+const validate = {};
 
-validator.hostName = (input) => {
+validate.hostName = (input) => {
   const regex = new RegExp(/^(?:[a-z-]+\.){1,3}[a-z-]+$/g);
-  if (input.match(regex)) {
-    return true;
-  }
+  if (input.match(regex)) return true;
   return 'Hostname must not include path to the page to run the check against or spaces';
 };
 
-validator.systemName = (input) => {
-  if (input.replace(/\s/g, '').length === 3) {
-    return true;
-  }
+validate.systemName = (input) => {
+  if (input.replace(/\s/g, '').length === 3) return true;
   return 'System name must be 3 characters';
 };
 
-validator.url = (input) => {
+validate.url = (input) => {
   // eslint-disable-next-line no-useless-escape
   const regex = new RegExp(/^https:\/\/[a-zA-Z]*.[a-zA-Z]*.[a-zA-Z]*\/[a-zA-Z\/+_-]*.$/g);
   if (regex.test(input) || input === '') return true;
   return 'You must enter a valid URL';
 };
 
-validator.instanceID = (input) => {
+validate.instanceID = (input) => {
   if (input.split('/').length === 6) return true;
   return 'You must enter the full instance path (example: projects/example/locations/europe-west1/instances/instanceID)';
 };
 
-validator.databaseId = (input) => {
+validate.databaseId = (input) => {
   if (input.split(':').length === 2) return true;
   return 'You must enter the full database path (example: my-project:databaseID)';
 };
 
-validator.pubSubSubscription = (input) => {
+validate.pubSubSubscription = (input) => {
   if (input.split('/').length === 4) return true;
   return 'You must enter the full subscription path (example: projects/example/subscriptions/subscriptionId)';
 };
 
-module.exports = validator;
+module.exports = validate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiiretail/gcp-infra-cli",
-  "version": "0.76.0",
+  "version": "0.76.1",
   "description": "Infrastructure as code generator for GCP.",
   "main": "src/cli.js",
   "bin": {

package/generators/resources/monitoring/append.js

@@ -1,105 +0,0 @@
-const fs = require('fs');
-const yaml = require('js-yaml');
-
-const appendIncludeConfigSlo = async (fileContent, originalContentYaml, slosFilePath, inputs) => {
-  if (fileContent !== null && fileContent !== '') {
-    const configArray = Object.values(originalContentYaml);
-    const yamlPullArray = yaml.dump(configArray);
-    fs.writeFileSync(slosFilePath, `${yamlPullArray}`);
-  }
-
-  const newPullArray = [];
-
-  const availabilityConf = {
-    display_name: 'Month - Availability',
-    slo_id: 'month-availability',
-    goal: 0.998,
-    calendar_period: 'MONTH',
-    type: 'windows_based_sli',
-    method: 'boolean_filter',
-    window_period: '60s',
-  };
-
-  if (inputs.sli === 'availability') {
-    if (inputs.burnRateAlerts === 'no') {
-      availabilityConf.alert = {};
-    }
-    newPullArray.push(availabilityConf);
-  }
-
-  const errorRateConf = {
-    display_name: 'Month - Error rate',
-    slo_id: 'month-error-rate',
-    goal: 0.999,
-    calendar_period: 'MONTH',
-    type: 'request_based_sli',
-    method: 'good_total_ratio',
-    bad_service_filter:
-`metric.type="knative.dev/serving/revision/request_count"
-resource.type="knative_revision"
-metric.labels.response_code_class="5xx"
-resource.labels.service_name="${inputs.serviceName}"`,
-    total_service_filter:
-`metric.type="knative.dev/serving/revision/request_count"
-resource.type="knative_revision"
-resource.labels.service_name=${inputs.serviceName}"`,
-  };
-
-  if (inputs.sli === 'error-rate') {
-    if (inputs.burnRateAlerts === 'no') {
-      errorRateConf.alert = {};
-    }
-    newPullArray.push(errorRateConf);
-  }
-
-  const latencyConf = {
-    display_name: 'Month - Latency',
-    slo_id: 'month-latency',
-    goal: 0.95,
-    calendar_period: 'MONTH',
-    type: 'request_based_sli',
-    method: 'distribution_cut',
-    metric_filter:
-`metric.type="knative.dev/serving/revision/request_latencies"
-resource.type="knative_revision"
-resource.labels.service_name="${inputs.serviceName}"`,
-    range_min: 0,
-    range_max: 100,
-  };
-
-  if (inputs.sli === 'latency') {
-    if (inputs.burnRateAlerts === 'no') {
-      latencyConf.alert = {};
-    }
-    newPullArray.push(latencyConf);
-  }
-
-  const finalYamlPullArray = yaml.dump(newPullArray);
-  fs.appendFileSync(slosFilePath, finalYamlPullArray);
-};
-
-const appendIncludeConfigUptime = async (fileContent, uptimeContentYml, uptimeFilePath, inputs) => {
-  if (fileContent !== null && fileContent !== '') {
-    const configArray = Object.values(uptimeContentYml);
-    const yamlPullArray = yaml.dump(configArray);
-    fs.writeFileSync(uptimeFilePath, `${yamlPullArray}`);
-  }
-
-  const newPullArray = [];
-
-  newPullArray.push(
-    {
-      service_name: `${inputs.systemName}.${inputs.serviceName}`,
-      hostname: inputs.hostname,
-      path: inputs.path,
-    },
-  );
-
-  const finalYamlPullArray = yaml.dump(newPullArray);
-  fs.appendFileSync(uptimeFilePath, finalYamlPullArray);
-};
-
-module.exports = {
-  appendIncludeConfigSlo,
-  appendIncludeConfigUptime,
-};

package/generators/resources/monitoring/handle-alerts.js

@@ -1,11 +0,0 @@
-const ejs = require('ejs');
-
-const handleAlerts = (alerts, templates, answers) => {
-  const template = templates[`${answers.alertResource}`][`${answers.alert}`];
-  const newAlert = ejs.render(JSON.stringify(template), answers);
-
-  alerts.push(JSON.parse(newAlert));
-  return alerts;
-};
-
-module.exports = handleAlerts;

package/generators/resources/monitoring/handle-slos.js

@@ -1,28 +0,0 @@
-const fs = require('fs');
-const yaml = require('js-yaml');
-const { appendIncludeConfigSlo } = require('./append');
-
-const handleSlosFile = async (answers, slosFilePath) => {
-  const {
-    serviceName,
-    sli,
-    systemName,
-    burnRateAlerts,
-  } = answers;
-
-  const sloFileContent = fs.readFileSync(slosFilePath, 'utf8');
-
-  const inputs = {
-    ...this.answers,
-    serviceName,
-    sli,
-    systemName,
-    burnRateAlerts,
-  };
-
-  const originalContentYaml = yaml.load(sloFileContent);
-  const fileContent = sloFileContent;
-  await appendIncludeConfigSlo(fileContent, originalContentYaml, slosFilePath, inputs);
-};
-
-module.exports = handleSlosFile;

package/generators/resources/monitoring/handle-uptime.js

@@ -1,28 +0,0 @@
-const fs = require('fs');
-const yaml = require('js-yaml');
-const { appendIncludeConfigUptime } = require('./append');
-
-const handleUptimeFile = async (answers, uptimeFilePath) => {
-  const {
-    serviceName,
-    hostname,
-    path,
-    systemName,
-  } = answers;
-
-  const uptimeFileContent = fs.readFileSync(uptimeFilePath, 'utf8');
-
-  const inputs = {
-    ...this.answers,
-    serviceName,
-    hostname,
-    path,
-    systemName,
-  };
-
-  const originalContentYaml = yaml.load(uptimeFileContent);
-  const fileContent = uptimeFileContent;
-  await appendIncludeConfigUptime(fileContent, originalContentYaml, uptimeFilePath, inputs);
-};
-
-module.exports = handleUptimeFile;