Add service to publish form counts to CloudWatch

Publishes form counts grouped by organisation and state so they can
be monitored in CloudWatch.

Author: theseanything

app/services/metrics/form_count_service.rb

@@ -0,0 +1,74 @@
+module Metrics
+  class FormCountService
+    METRIC_NAME = "FormCount".freeze
+    METRICS_NAMESPACE = CloudWatchService::METRICS_NAMESPACE
+    REGION = CloudWatchService::REGION
+    BATCH_SIZE = 500
+    UNKNOWN_ORG = "Unknown".freeze
+
+    def publish_form_counts
+      metric_count = 0
+
+      form_counts_by_org_and_state.each_slice(BATCH_SIZE) do |batch|
+        cloudwatch_client.put_metric_data(
+          namespace: METRICS_NAMESPACE,
+          metric_data: batch.map { |((org, state), count)| metric_datum(org:, state:, count:) },
+        )
+        metric_count += batch.size
+      end
+
+      Rails.logger.info "Published #{metric_count} form count metrics to CloudWatch"
+    rescue Aws::CloudWatch::Errors::ServiceError,
+           Aws::Errors::MissingCredentialsError => e
+      Sentry.capture_exception(e)
+      raise
+    end
+
+  private
+
+    def form_counts_by_org_and_state
+      counts_by_org_and_state = Form
+        .where.not(state: :deleted)
+        .left_joins(group_form: { group: :organisation })
+        .group(Organisation.arel_table[:name], Form.arel_table[:state])
+        .count
+
+      counts_by_org_and_state.each_with_object(Hash.new(0)) do |((org_name, state), count), totals|
+        totals[[org_name || UNKNOWN_ORG, metric_state(state)]] += count
+      end
+    end
+
+    def metric_state(state)
+      case state
+      when "live", "live_with_draft" then "live"
+      when "archived", "archived_with_draft" then "archived"
+      when "draft" then "draft"
+      end
+    end
+
+    def metric_datum(org:, state:, count:)
+      {
+        metric_name: METRIC_NAME,
+        dimensions: [
+          environment_dimension,
+          { name: "Org", value: org },
+          { name: "State", value: state },
+        ],
+        value: count,
+        unit: "Count",
+        timestamp: Time.zone.now,
+      }
+    end
+
+    def environment_dimension
+      {
+        name: "Environment",
+        value: Settings.forms_env.downcase,
+      }
+    end
+
+    def cloudwatch_client
+      @cloudwatch_client ||= Aws::CloudWatch::Client.new(region: REGION)
+    end
+  end
+end

spec/services/metrics/form_count_service_spec.rb

@@ -0,0 +1,84 @@
+require "rails_helper"
+
+describe Metrics::FormCountService do
+  subject(:service) { described_class.new }
+
+  let(:forms_env) { "test" }
+  let(:cloud_watch_client) { Aws::CloudWatch::Client.new(stub_responses: true) }
+  let(:organisation) { create(:organisation, name: "Department for Testing") }
+  let(:group) { create(:group, organisation:) }
+
+  before do
+    allow(Settings).to receive(:forms_env).and_return(forms_env)
+    allow(Aws::CloudWatch::Client).to receive(:new).and_return(cloud_watch_client)
+  end
+
+  around do |example|
+    travel_to(Time.zone.local(2026, 6, 3, 12, 0, 0)) do
+      example.run
+    end
+  end
+
+  describe "#publish_form_counts" do
+    before do
+      Form.destroy_all
+
+      create(:form, :with_group, group:, state: :draft)
+      create(:form, :live, :with_group, group:)
+      create(:form, :live_with_draft, :with_group, group:)
+      create(:form, :archived, :with_group, group:)
+      create(:form, :archived_with_draft, :with_group, group:)
+      create(:form, state: :draft)
+    end
+
+    it "publishes grouped form counts to CloudWatch" do
+      expect(cloud_watch_client).to receive(:put_metric_data).with(
+        namespace: "Forms",
+        metric_data: contain_exactly(
+          metric_datum(org: organisation.name, state: "draft", count: 1),
+          metric_datum(org: organisation.name, state: "live", count: 2),
+          metric_datum(org: organisation.name, state: "archived", count: 2),
+          metric_datum(org: "Unknown", state: "draft", count: 1),
+        ),
+      )
+
+      service.publish_form_counts
+    end
+
+    context "when CloudWatch returns an error" do
+      before do
+        allow(cloud_watch_client).to receive(:put_metric_data)
+          .and_raise(Aws::CloudWatch::Errors::ServiceError.new(nil, "CloudWatch error", nil))
+      end
+
+      it "captures the exception and re-raises" do
+        expect(Sentry).to receive(:capture_exception).with(instance_of(Aws::CloudWatch::Errors::ServiceError))
+
+        expect { service.publish_form_counts }.to raise_error(Aws::CloudWatch::Errors::ServiceError)
+      end
+    end
+  end
+
+  def metric_datum(org:, state:, count:)
+    {
+      metric_name: "FormCount",
+      dimensions: [
+        {
+          name: "Environment",
+          value: forms_env,
+        },
+        {
+          name: "Org",
+          value: org,
+        },
+        {
+          name: "State",
+          value: state,
+        },
+      ],
+      value: count,
+      unit: "Count",
+      timestamp: Time.zone.local(2026, 6, 3, 12, 0, 0),
+    }
+  end
+end