@hiiretail/gcp-infra-cli 0.76.0 → 0.76.3

package/generators/init/clan-infra/index.js

@@ -4,6 +4,7 @@ const BaseGenerator = require('../../../src/BaseGenerator');
 const { chain, required } = require('../../../src/validators');
 const { getGcpProjects, validateGcpProjects } = require('./gcp-projects');
 const getTribeAndClanName = require('./tribe-clan-repo');
+const validate = require('./validate');
 
 module.exports = class extends BaseGenerator {
   prompting() {
@@ -36,6 +37,12 @@ module.exports = class extends BaseGenerator {
         message: 'Provide the cost center your tribe belongs to',
         validate: required,
       },
+      {
+        type: 'input',
+        name: 'jiraProjectKey',
+        message: 'Provide the "jira project key" for your clan (the uppercase prefix in your task names, example: SRT)',
+        validate: required && validate.jiraProjectKey,
+      },
       {
         type: 'input',
         name: 'repoName',

package/generators/init/clan-infra/templates/infra/common.hcl

@@ -12,4 +12,5 @@ locals {
   ]
   project_id_slack_token = "tf-admin-90301274"
   cost_center            = "<%-costCenter%>"
+  jira_project_key       = "<%-jiraProjectKey%>"
 }

package/generators/init/clan-infra/validate.js

@@ -0,0 +1,8 @@
+const validate = {};
+
+validate.jiraProjectKey = (input) => {
+  if (!/\s/.test(input) && input === input.toUpperCase()) return true;
+  return 'Must be uppercase and not contain any whitepace';
+};
+
+module.exports = validate;

package/generators/resources/cloud-storage/templates/cloud-storage/storage.yaml

@@ -0,0 +1,23 @@
+names:
+  - "<%-bucketName%>"
+prefix: "<%-prefix%>"
+storage_class: "STANDARD" <% if (env == 'prod') { %>
+location: "EU" <% } else { %>
+location: "EUROPE-WEST1"<% } %>
+versioning:
+  "<%-bucketName%>": <%-versioning%>
+set_viewer_roles: true <% if (lifecycleRules == 'true') { %>
+lifecycle_rules:
+  action:
+    type: "<%-action%>" <% if (action == 'SetStorageClass') { %>
+    storage_class: "<%-storageClass%>" <% } else { %>
+    storage_class: null <% } %>
+  condition:
+    age: <%-age%> <% if (createdBefore != 'null') { %>
+    created_before: "<%-createdBefore%>" <% } else { %>
+    created_before: null <% } %> <% if (withState != 'null') { %>
+    with_state: "<%-withState%>" <% } else { %>
+    with_state: null <% } %> <% if (matchesStorageClass != 'null') { %>
+    matches_storage_class: "<%-matchesStorageClass%>" <% } else { %>
+    matches_storage_class: null <% } %>
+    num_newer_versions: <%-numNewerVersions%> <% } %>

package/generators/resources/cloud-storage/templates/cloud-storage/terragrunt.hcl

@@ -10,14 +10,13 @@ include {
 }
 
 locals {
-  spec_vars    = read_terragrunt_config("${get_terragrunt_dir()}/spec.hcl")
   project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
   common_vars  = read_terragrunt_config(find_in_parent_folders("common.hcl"))
 }
 
 # These are the variables we have to pass in to use the module specified in the terragrunt configuration above
 inputs = merge(
-  local.spec_vars.locals,
+  yamldecode(file("${get_terragrunt_dir()}/storage.yaml")),
   local.project_vars.locals,
   {
     project_id = local.project_vars.locals.project_id

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.common_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
+  goal: 0.999
   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,10 +9,10 @@ include {
   path = find_in_parent_folders("terragrunt_root.hcl")
 }
 
-dependency "uptimecheck_id" {
-  config_path  = "../../uptime-checks"
+dependency "notification_channels" {
+  config_path  = "../../notification-channels"
   mock_outputs = {
-    uptime_check_ids = ["dummy-id"]
+    notification_channels = ["dummy-channel"]
   }
 }
 
@@ -25,13 +25,9 @@ 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),
+    notification_channels   = dependency.notification_channels.outputs.notification_channels,
+    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%>"
     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%>"]
-    }<% } %>
   }
 )

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,38 @@
-const validator = {};
+const validate = {};
 
-validator.hostName = (input) => {
+const hasWhitespace = (str) => /\s/.test(str);
+
+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.length === 3 && !hasWhitespace(input)) 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;
+  if ((regex.test(input) && !hasWhitespace(input)) || input === '') return true;
   return 'You must enter a valid URL';
 };
 
-validator.instanceID = (input) => {
-  if (input.split('/').length === 6) return true;
+validate.instanceID = (input) => {
+  if (input.split('/').length === 6 && !hasWhitespace(input)) return true;
   return 'You must enter the full instance path (example: projects/example/locations/europe-west1/instances/instanceID)';
 };
 
-validator.databaseId = (input) => {
-  if (input.split(':').length === 2) return true;
+validate.databaseId = (input) => {
+  if (input.split(':').length === 2 && !hasWhitespace(input)) return true;
   return 'You must enter the full database path (example: my-project:databaseID)';
 };
 
-validator.pubSubSubscription = (input) => {
-  if (input.split('/').length === 4) return true;
+validate.pubSubSubscription = (input) => {
+  if (input.split('/').length === 4 && !hasWhitespace(input)) 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.3",
   "description": "Infrastructure as code generator for GCP.",
   "main": "src/cli.js",
   "bin": {

package/generators/resources/cloud-storage/templates/cloud-storage/spec.hcl

@@ -1,47 +0,0 @@
-locals {
-  ###################
-  # REQUIRED INPUTS #
-  ###################
-
-  names = ["<%-bucketName%>"]
-  prefix = "<%-prefix%>"
-
-
-  ###################
-  # OPTIONAL INPUTS #
-  ###################
-
-  # The Storage Class of the new bucket.
-  # Supported values include: STANDARD, MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, ARCHIVE.
-  storage_class = "STANDARD"
-
-  # The GCS location - 'EU' for multi-regional buckets.
-  <% if (env == 'prod') { %>
-  location = "EU"
-  <% } else { %>
-  location = "EUROPE-WEST1"
-  <% } %>
-  versioning = {
-    "<%-bucketName%>" = <%-versioning%>
-  }
-  set_viewer_roles = true
-
-  <% if (lifecycleRules == 'true') { %>
-  lifecycle_rules = [{
-    action = {
-      type          = "<%-action%>" <% if (action == 'SetStorageClass') { %>
-      storage_class = "<%-storageClass%>" <% } else { %>
-      storage_class = null <% } %>
-    }
-    condition = {
-      age                   = <%-age%> <% if (createdBefore != 'null') { %>
-      created_before        = "<%-createdBefore%>" <% } else { %>
-      created_before        = null <% } %> <% if (withState != 'null') { %>
-      with_state            = "<%-withState%>" <% } else { %>
-      with_state            = null <% } %> <% if (matchesStorageClass != 'null') { %>
-      matches_storage_class = "<%-matchesStorageClass%>" <% } else { %>
-      matches_storage_class = null <% } %>
-      num_newer_versions    = <%-numNewerVersions%>
-    }
-  }] <% } %>
-}

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;