@hiiretail/gcp-infra-cli 0.71.0 → 0.74.0

package/generators/init/clan-infra/templates/env/project.hcl

@@ -5,7 +5,8 @@ locals {
   project_id   = "<%-clanProject%>"
   project_env  = "<%-env%>"
 
-  project          = local.project_id
-  network          = "tribe-network"
-  tribe_project_id = "<%-tribeProject%>"
+  project               = local.project_id
+  network               = "tribe-network"
+  tribe_project_id      = "<%-tribeProject%>"
+  monitoring_project_id = "<%-tribeProject%>" #  possibly will be changed to hiiretail-monitoring-prod-6500 later
 }

package/generators/init/clan-infra/templates/infra/.terraform-version

@@ -1 +1 @@
-1.0.7
+1.2.7

package/generators/init/clan-infra/templates/infra/.terragrunt-version

@@ -1 +1 @@
-0.31.8
+0.38.0

package/generators/organization/clan-project/index.js

@@ -123,7 +123,7 @@ module.exports = class extends BaseGenerator {
     this.log(`
 ${chalk.green('Your clan projects have now been created. To finalize your configuration, please continue with manual editing of the generated files.')}
 ${chalk.green('1.')} Add clan members and groups
-   \u2192 ${chalk.cyan(path.join(clanDir, 'project.yaml'))}
+   \u2192 ${chalk.cyan(path.join(clanDir, 'clan.yaml'))}
 ${chalk.green('2.')} Configure APIs, service accounts and repositories
    \u2192 ${chalk.cyan(path.join(clanDir, 'prod', 'project.yaml'))}
    \u2192 ${chalk.cyan(path.join(clanDir, 'staging', 'project.yaml'))}

package/generators/organization/clan-project/templates/clan/clan.yaml

@@ -8,8 +8,10 @@
 # members:
 #   groups: []
 #    users:
-#       - alice@extendaretail.com
-#       - bob@extendaretail.com
+#       - name: Alice Test
+#         email: alice@extendaretail.com
+#       - name: Bob Test
+#         email: bob@extendaretail.com
 ###
 ---
 common-infra-repo: <%-commonInfraRepo%>

package/generators/organization/clan-project/templates/clan-project/terragrunt.hcl

@@ -1,5 +1,5 @@
 terraform {
-  source = "git::https://github.com/extenda/tf-module-gcp-project//?ref=v1.0.6"
+  source = "git::https://github.com/extenda/tf-module-gcp-project//?ref=v1.0.8"
 }
 
 dependency "parent_folder" {

package/generators/resources/monitoring/append.js

@@ -0,0 +1,105 @@
+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/generator.json

@@ -1,4 +1,4 @@
 {
   "name": "Monitoring",
-  "description": "Create monitoring dashboards and alers"
+  "description": "Create monitoring resources"
 }

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,28 @@
+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;

package/generators/resources/monitoring/index.js

@@ -1,55 +1,244 @@
 const path = require('path');
 const chalk = require('chalk');
+const fs = require('fs');
+const yaml = require('js-yaml');
 const BaseGenerator = require('../../../src/BaseGenerator');
+const { required } = require('../../../src/validators');
+const helper = require('./validate');
+const handleSlosFile = require('./handle-slos');
+const handleUptimeFile = require('./handle-uptime');
+const handleAlerts = require('./handle-alerts');
+
+const alertTemplates = yaml.load(fs.readFileSync(`${__dirname}/templates/alerts/alerts.yaml`));
 
 module.exports = class extends BaseGenerator {
-  prompting() {
-    const prompts = [
+  async prompting() {
+    this.answers = await this.prompt([
       {
         type: 'list',
         name: 'monitoringResource',
-        message: 'Select the resource that you want to monitor',
-        default: 'dataflow',
-        choices: ['cloudrun', 'cloudfunction', 'dataflow'],
+        message: 'Select the resource you want to create',
+        choices: ['alerts', 'uptime-checks', 'slos'],
       },
-    ];
-
-    return this.prompt(prompts).then((props) => {
-      this.answers = props;
-    });
+      {
+        when: (response) => response.monitoringResource === 'alerts',
+        type: 'list',
+        name: 'alertResource',
+        choices: Object.keys(alertTemplates),
+      },
+      {
+        when: (response) => response.monitoringResource === 'alerts',
+        type: 'list',
+        name: 'alert',
+        choices: (answers) => Object.keys(alertTemplates[`${answers.alertResource}`]),
+      },
+      {
+        when: (response) => response.monitoringResource === ('alerts' || 'slos' || 'uptime-checks'),
+        type: 'input',
+        name: 'systemName',
+        message: 'Please provide three-letter system name as defined in Styra',
+        validate: required && helper.validSystemName,
+      },
+      {
+        when: (response) => response.monitoringResource === ('slos' || 'uptime-checks') || response.alertResource === 'cloud_run',
+        type: 'input',
+        name: 'serviceName',
+        message: 'Please provide the namespace where the service resides',
+        validate: required,
+      },
+      {
+        when: (response) => response.monitoringResource === 'alerts',
+        type: 'input',
+        name: 'runbookLink',
+        message: 'Please provide the full URL to your runbook in confluence (Leave empty if none)',
+        validate: required && helper.validUrl,
+      },
+      {
+        when: (response) => response.alertResource === 'cloud_scheduler',
+        type: 'input',
+        name: 'jobId',
+        message: 'Please provide the "job id"',
+        validate: required,
+      },
+      {
+        when: (response) => response.alertResource === 'cloud_sql',
+        type: 'input',
+        name: 'databaseId',
+        message: 'Please provide the "database id"',
+        validate: required,
+      },
+      {
+        when: (response) => response.alertResource === 'memorystore',
+        type: 'input',
+        name: 'instanceId',
+        message: 'Please provide the "instance id"',
+        validate: required,
+      },
+      {
+        when: (response) => response.alertResource === 'pub_sub',
+        type: 'input',
+        name: 'subscriptionId',
+        message: 'Please provide the "subscription id"',
+        validate: required,
+      },
+      {
+        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 && helper.validHostname,
+      },
+      {
+        when: (response) => response.monitoringResource === 'uptime-checks',
+        type: 'input',
+        name: 'path',
+        message: 'Please provide the path to the page to run the check against. (example: /health)',
+        validate: required,
+      },
+      {
+        when: (response) => response.monitoringResource === 'slos',
+        type: 'list',
+        name: 'sli',
+        message: 'Please select the SLI',
+        choices: ['availability', 'error-rate', 'latency'],
+      },
+      {
+        when: (response) => response.monitoringResource === 'slos',
+        type: 'list',
+        name: 'burnRateAlerts',
+        message: 'Please select yes if you want to create burn rate alert for the SLI',
+        default: 'yes',
+        choices: ['yes', 'no'],
+      },
+      {
+        when: (response) => response.monitoringResource === 'slos' && response.sli === 'availability',
+        type: 'confirm',
+        name: 'info',
+        message: 'WARNING: Make sure that an uptime check has been created before applying availability SLI',
+      },
+    ]);
   }
 
-  writing() {
+  async writing() {
     const {
       monitoringResource,
+      serviceName,
+      hostname,
+      sli,
+      systemName,
+      burnRateAlerts,
     } = this.answers;
 
-    ['prod', 'staging'].forEach((env) => {
-      this.copyDir(
-        path.join(monitoringResource),
-        path.join('infra', env, 'monitoring', monitoringResource),
-        {
-          ...this.answers,
-          env,
-        },
-      );
-    });
-
-    ['prod', 'staging'].forEach((env) => {
-      this.copyDir(
-        'notification-channels',
-        path.join('infra', env, 'monitoring', 'notification-channels'),
-        {
-          ...this.answers,
-          env,
-        },
-      );
-    });
+    const resourcePath = path.join(process.cwd(), 'infra', 'prod', 'monitoring', monitoringResource);
+
+    if (monitoringResource === 'uptime-checks') {
+      if (!fs.existsSync(resourcePath)) {
+        fs.mkdirSync(resourcePath, { recursive: true });
+      }
+
+      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);
+      }
+    }
+
+    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 });
+      }
+
+      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,
+          },
+        );
+      }
+
+      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);
+      }
+    }
+
+    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, '');
+
+      if (!fs.existsSync(terraPath)) {
+        this.fs.copyTpl(
+          this.templatePath('alerts/terragrunt.hcl'),
+          this.destinationPath(terraPath),
+          this.answers,
+        );
+      }
+
+      const oldYaml = yaml.load(fs.readFileSync(yamlPath, 'utf8')) || [];
+      const newYaml = await handleAlerts(oldYaml, alertTemplates, this.answers);
+
+      fs.writeFileSync(yamlPath, yaml.dump(newYaml));
+    }
   }
 
   end() {
     this.log(`
 ${chalk.green('Your Monitoring resources have now been created.')}
-${chalk.green('1.')} Push this change in a feature branch and open a pull request.`);
+${chalk.green('1.')} To finalize your configuration, please continue with manual editing of the generated files.
+${chalk.green('2.')} Push the changes in a feature branch and open a pull request.
+`);
   }
 };

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

@@ -0,0 +1,257 @@
+cloud_run:
+  error_count:
+    display_name: "[P3] <%-systemName%>.<%-serviceName%> | 5xx Error Request Count above 1"
+    conditions:
+      - display_name: Cloud Run Anthos - 5xx error Request Count above 1
+        condition_threshold:
+          filter: |
+            resource.type="knative_revision"
+            resource.labels.service_name="<%-serviceName%>"
+            metric.type="knative.dev/serving/revision/request_count"
+            metric.labels.response_code_class="5xx"
+          threshold_value: 1
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_SUM
+              group_by_fields:
+                - metric.label.response_code_class
+              per_series_aligner: ALIGN_DELTA
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  error_rate:
+    display_name: "[P3] <%-systemName%>.<%-serviceName%> | High 5xx Error Rate"
+    conditions:
+      - display_name: Cloud Run Anthos - 3% of all requests during 10min are 5xx
+        condition_monitoring_query_language:
+          query: |
+            fetch knative_revision::knative.dev/serving/revision/request_count
+              | filter service_name = "store-data-resolver"
+              | align int_mean_aligner(10m)
+              | group_by [],    sum(if(metric.response_code_class == '5xx', val(), 0)) / sum(val())
+              | condition val() > 0.03
+              | every 10m
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  request_latency:
+    display_name: "[P3] <%-systemName%>.<%-serviceName%> | High Request Latency"
+    conditions:
+      - display_name: Cloud Run Anthos - Response Time (95%) above 1s for 5 min
+        condition_threshold:
+          filter: |
+            resource.type="knative_revision"
+            resource.labels.service_name="<%-serviceName%>"
+            metric.type="knative.dev/serving/revision/request_latencies"
+          threshold_value: 1000
+          duration: 300s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_PERCENTILE_95
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+cloud_scheduler:
+  failed_job:
+    display_name: "[P4] <%-systemName%> - Cloud Scheduler | <%-jobId%> - Job Failed"
+    conditions:
+      - display_name: Cloud Scheduler Job - Log entries with SEVERITY=Error exceed threshold
+        condition_threshold:
+          filter: |
+            resource.type="cloud_scheduler_job"
+            resource.labels.job_id="<%-jobId%>"
+            metric.type="logging.googleapis.com/log_entry_count"
+            metric.labels.severity="ERROR"
+          threshold_value: 1
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_COUNT
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+cloud_sql:
+  cpu_over_65:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - CPU over 65%"
+    conditions:
+      - display_name: Cloud SQL Database - CPU utilization above 65% over 5 min
+        condition_threshold:
+          filter: |
+            resource.type="cloudsql_database"
+            resource.labels.database_id="<%-databaseId%>"
+            metric.type="cloudsql.googleapis.com/database/cpu/utilization"
+          threshold_value: 0.65
+          duration: 300s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  cpu_over_85:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - CPU over 85%"
+    conditions:
+      - display_name: "Cloud SQL Database - CPU-usage above 85% over 1 min"
+        condition_threshold:
+          filter: |
+            resource.type="cloudsql_database"
+            resource.labels.database_id="<%-databaseId%>"
+            metric.type="cloudsql.googleapis.com/database/cpu/utilization"
+          threshold_value: 0.85
+          duration: 60s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  cpu_over_90:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - CPU over 90%"
+    conditions:
+      - display_name: Cloud SQL Database - CPU-usage above 90%
+        condition_threshold:
+          filter: |
+            resource.type="cloudsql_database"
+            resource.labels.database_id="<%-databaseId%>"
+            metric.type="cloudsql.googleapis.com/database/cpu/utilization"
+          threshold_value: 0.9
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  memory_over_50:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - Memory over 50%"
+    conditions:
+    - display_name: Cloud SQL Database - Memory utilization above 50% over 5 min
+      condition_threshold:
+        filter: |
+          resource.type="cloudsql_database"
+          resource.labels.database_id="<%-databaseId%>"
+          metric.type="cloudsql.googleapis.com/database/memory/utilization"
+        threshold_value: 50
+        duration: 300s
+        aggregations:
+        - alignment_period: 60s
+          cross_series_reducer: REDUCE_NONE
+          per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  memory_over_75:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - Memory over 75%"
+    conditions:
+    - display_name: Cloud SQL Database - Memory utilization above 75% over 5 min
+      condition_threshold:
+        filter: |
+          resource.type="cloudsql_database"
+          resource.labels.database_id="<%-databaseId%>"
+          metric.type="cloudsql.googleapis.com/database/memory/utilization"
+        threshold_value: 75
+        duration: 300s
+        aggregations:
+        - alignment_period: 60s
+          cross_series_reducer: REDUCE_NONE
+          per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  memory_over_90:
+    display_name: "[P3] <%-systemName%> - CloudSQL | <%-databaseId%> - Memory over 90%"
+    conditions:
+    - display_name: Cloud SQL Database - Memory utilization above 90%
+      condition_threshold:
+        filter: |
+          resource.type="cloudsql_database"
+          resource.labels.database_id="<%-databaseId%>"
+          metric.type="cloudsql.googleapis.com/database/memory/utilization"
+        threshold_value: 90
+        duration: 60s
+        aggregations:
+        - alignment_period: 60s
+          cross_series_reducer: REDUCE_NONE
+          per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  query_over_1s:
+    display_name: "[P4] <%-systemName%> - CloudSQL | <%-databaseId%> - Query resolve time"
+    conditions:
+      - display_name: Cloud SQL Instance Database - Per query execution times above 1000 ms
+        condition_threshold:
+          filter: |
+            resource.type="cloudsql_instance_database"
+            resource.labels.resource_id="<%-databaseId%>"
+            metric.type="cloudsql.googleapis.com/database/postgresql/insights/perquery/execution_time"
+          threshold_value: 1000000
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_DELTA
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+memorystore:
+  memory_over_50:
+    display_name: "[P4] <%-systemName%> - Memorystore | <%-instanceId%> - Memory over 50%"
+    conditions:
+      - display_name: Memorystore Redis Instance - Memory Usage above 50% over 5 min
+        condition_threshold:
+          filter: |
+            resource.type="redis_instance"
+            resource.labels.instance_id="<%-instanceId%>"
+            metric.type="redis.googleapis.com/stats/memory/usage_ratio"
+          threshold_value: 0.5
+          duration: 300s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  memory_over_75:
+    display_name: "[P4] <%-systemName%> - Memorystore | <%-instanceId%> - Memory over 75%"
+    conditions:
+      - display_name: Memorystore Redis Instance - Memory Usage above 75% for 5min
+        condition_threshold:
+          filter: |
+            resource.type="redis_instance"
+            resource.labels.instance_id="<%-instanceId%>"
+            metric.type="redis.googleapis.com/stats/memory/usage_ratio"
+          threshold_value: 0.75
+          duration: 300s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+  memory_over_90:
+    display_name: "[P2] <%-systemName%> - Memorystore | <%-instanceId%> - Memory over 90%"
+    conditions:
+      - display_name: Memorystore Redis Instance - Memory Usage above 90%
+        condition_threshold:
+          filter: |
+            resource.type="redis_instance"
+            resource.labels.instance_id="<%-instanceId%>"
+            metric.type="redis.googleapis.com/stats/memory/usage_ratio"
+          threshold_value: 0.90
+          duration: 60s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MAX
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>
+pub_sub:
+  unacknowledged_messages:
+    display_name: "[P4] <%-systemName%> - Pub/Sub | <%-subscriptionId%> - Undelivered message(s)"
+    conditions:
+      - display_name: Cloud Pub/Sub Subscription - Undelivered messages above 1 for 5 min
+        condition_threshold:
+          filter: |
+            resource.type="pubsub_subscription"
+            resource.labels.subscription_id="<%-subscriptionId%>"
+            metric.type="pubsub.googleapis.com/subscription/num_undelivered_messages"
+          threshold_value: 1
+          duration: 300s
+          aggregations:
+            - alignment_period: 60s
+              cross_series_reducer: REDUCE_NONE
+              per_series_aligner: ALIGN_MEAN
+    documentation:
+      content: <% if (runbookLink) { %>[Runbook](<%-runbookLink%>)<%} else { %> <% } %>

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

@@ -0,0 +1,33 @@
+# Terragrunt will copy the Terraform configurations specified by the source parameter, along with any files in the
+# working directory, into a temporary folder, and execute your Terraform commands in that folder.
+terraform {
+  source = "git::https://github.com/extenda/tf-module-gcp-alert-policy//?ref=v0.1.0"
+}
+
+# Include all settings from the root terragrunt.hcl file
+include {
+  path = find_in_parent_folders("terragrunt_root.hcl")
+}
+
+dependency "notification_channels" {
+  config_path  = "../notification-channels"
+  mock_outputs = {
+    notification_channels = ["dummy-channel"]
+  }
+}
+
+locals {
+  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 = {
+  monitoring_project_id   = local.project_vars.locals.monitoring_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
+  },
+}

package/generators/resources/monitoring/templates/notification-channels/terragrunt.hcl

@@ -18,5 +18,7 @@ locals {
 inputs = merge(local.project_vars.locals, local.common_vars.locals,
   {
     clan_project_id  = local.project_vars.locals.project_id
+    # Use var below if we decide to go with hiiretail-monitoring-prod project
+    #tribe_project_id = local.common_vars.locals.monitoring_project_id
   }
 )

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

@@ -0,0 +1,35 @@
+<% 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
+  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
+  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="<%-serviceName%>"
+  total_service_filter: |-
+    metric.type="knative.dev/serving/revision/request_count"
+    resource.type="knative_revision"
+    resource.labels.service_name="<%-serviceName%>"<% if (burnRateAlerts === 'no') { %>
+  alert: {}<% } %><% } %>

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

@@ -0,0 +1,37 @@
+# Terragrunt will copy the Terraform configurations specified by the source parameter, along with any files in the
+# working directory, into a temporary folder, and execute your Terraform commands in that folder.
+terraform {
+  source = "git::https://github.com/extenda/tf-module-gcp-slo//?ref=v0.1.0"
+}
+
+# Include all settings from the root terragrunt.hcl file
+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"))
+}
+
+# These are the variables we have to pass in to use the module specified in the terragrunt configuration above
+inputs = merge(
+  local.project_vars.locals,
+  {
+    service_name            = "<%-systemName%>.<%-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

@@ -0,0 +1,36 @@
+# Terragrunt will copy the Terraform configurations specified by the source parameter, along with any files in the
+# working directory, into a temporary folder, and execute your Terraform commands in that folder.
+terraform {
+  source = "git::https://github.com/extenda/tf-module-gcp-uptime-check//?ref=v0.1.0"
+}
+
+# Include all settings from the root terragrunt.hcl file
+include {
+  path = find_in_parent_folders("terragrunt_root.hcl")
+}
+
+dependency "notification_channels" {
+  config_path  = "../notification-channels"
+  mock_outputs = {
+    notification_channels = ["dummy-channel"]
+  }
+}
+
+locals {
+  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.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
+    }
+  }
+)

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

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

package/generators/resources/monitoring/validate.js

@@ -0,0 +1,25 @@
+const helper = {};
+
+helper.validHostname = (input) => {
+  const regex = new RegExp(/^(?:[a-z-]+\.){1,3}[a-z-]+$/g);
+  if (input.match(regex)) {
+    return true;
+  }
+  return 'Hostname must not include path to the page to run the check against or spaces';
+};
+
+helper.validSystemName = (input) => {
+  if (input.replace(/\s/g, '').length === 3) {
+    return true;
+  }
+  return 'System name must be 3 characters';
+};
+
+helper.validUrl = (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 'Enter a valid URL';
+};
+
+module.exports = helper;

package/generators/tribe-resources/tribe-project/templates/project/terragrunt.hcl

@@ -1,5 +1,5 @@
 terraform {
-  source = "git::https://github.com/extenda/tf-module-gcp-project//?ref=v1.0.6"
+  source = "git::https://github.com/extenda/tf-module-gcp-project//?ref=v1.0.8"
 }
 
 dependency "tribe_folder" {

package/package.json

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