feat: Add counter metrics for consumed cycles (#9922)

Add counter versions of metrics for consumed cycles that are stored in
`ReplicatedState`. The existing ones behave like gauges (so their values
can go down when prepayments are made and up when refunds are issued)
which makes it more challenging for consumers to build automated
monitoring tools to perform aggregations over them. By having them
monotonically increase, it's easier to calculate rates of change, show
aggregates over time etc.

The key idea is to introduce a second map of `<CyclesUseCase,
NominalCycles>` in the `ReplicatedState` that will only be updated once
per use case: either at the payment stage if we know the precise amount
or only at refund stage if a prepayment is made with an expected refund
later. The second map is quite similar to the existing in all other
aspects (how they are stored in checkpoints or how they are exposed as
prometheus metrics) besides how the values are updated.

A new map is introduced to ease the transition as migrating from the old
map to new is non-trivial given that a proper cutoff point needs to be
introduced to handle outstanding callbacks that might have been created
before the metric introduction. This is left for a follow-up if and when
people decide to do it. The new map will be used in a follow up that
will implement the [new management canister
endpoint](dfinity/portal#6217) to retrieve
canister level metrics.

Additionally, the new metrics include the use case `HttpsOutcalls` in
the canister level metrics as it's useful to determine how much each
canister uses this feature. I've opted to not change existing metrics to
do the same as it would make things less clean imo than the current
approach -- a single specific API is used to perform this update in
exactly one place where it's needed.

The changes in the PR are mostly driven by the addition of the new map
of metrics, updates in protobuf files to store the new metrics, the
changes to support having the `HttpsOutcalls` use case additionally
included as well as some changes in tests to support the new metrics.

Author: dsarlis

rs/execution_environment/src/execution/response/tests.rs

@@ -98,25 +98,30 @@ fn execute_response_refunds_cycles() {
 
         // Canister A calls canister B.
         let cycles_sent = Cycles::new(1_000_000);
+        let b_callback = wasm()
+            .accept_cycles(cycles_sent / 2_u64)
+            .message_payload()
+            .append_and_reply()
+            .build();
         let wasm_payload = wasm()
-            .call_with_cycles(b_id, "update", call_args(), cycles_sent)
+            .call_with_cycles(
+                b_id,
+                "update",
+                call_args().other_side(b_callback.clone()),
+                cycles_sent,
+            )
             .build();
 
         // Enqueue ingress message to canister A and execute it.
         let msg_id = test.ingress_raw(a_id, "update", wasm_payload).0;
         assert_matches!(test.ingress_state(&msg_id), IngressState::Received);
         test.execute_message(a_id);
 
-        // Create response from canister B to canister A.
-        let response = ResponseBuilder::new()
-            .originator(a_id)
-            .respondent(b_id)
-            .originator_reply_callback(CallbackId::from(1))
-            .refund(cycles_sent / 2_u64)
-            .build();
-        let response_payload_size = response.payload_size_bytes();
+        // Execute message on B.
+        test.induct_messages();
+        test.execute_message(b_id);
 
-        // Execute response.
+        // Execute response on A.
         let balance_before = test.canister_state(a_id).system_state.balance();
         let consumed_cycles_before = *test
             .canister_state(a_id)
@@ -125,8 +130,16 @@ fn execute_response_refunds_cycles() {
             .consumed_cycles_by_use_cases()
             .get(&CyclesUseCase::RequestAndResponseTransmission)
             .unwrap();
+        let consumed_cycles_before_counter = *test
+            .canister_state(a_id)
+            .system_state
+            .canister_metrics()
+            .consumed_cycles_by_use_cases_as_counters()
+            .get(&CyclesUseCase::RequestAndResponseTransmission)
+            .unwrap();
         let instructions_before = test.canister_executed_instructions(a_id);
-        test.execute_response(a_id, response);
+        test.induct_messages();
+        test.execute_message(a_id);
         let instructions_after = test.canister_executed_instructions(a_id);
         let instructions_executed = instructions_after - instructions_before;
         let balance_after = test.canister_state(a_id).system_state.balance();
@@ -137,6 +150,13 @@ fn execute_response_refunds_cycles() {
             .consumed_cycles_by_use_cases()
             .get(&CyclesUseCase::RequestAndResponseTransmission)
             .unwrap();
+        let consumed_cycles_after_counter = *test
+            .canister_state(a_id)
+            .system_state
+            .canister_metrics()
+            .consumed_cycles_by_use_cases_as_counters()
+            .get(&CyclesUseCase::RequestAndResponseTransmission)
+            .unwrap();
 
         // The balance is equivalent to the amount of cycles before executing`execute_response`
         // plus the unaccepted cycles (no more the cycles sent via request),
@@ -146,7 +166,7 @@ fn execute_response_refunds_cycles() {
         let prepayment_for_response_transmission =
             mgr.prepayment_for_response_transmission(test.subnet_size(), cost_schedule);
         let actual_response_transmission_fee = mgr.xnet_call_bytes_transmitted_fee(
-            response_payload_size,
+            NumBytes::from(b_callback.len() as u64),
             test.subnet_size(),
             cost_schedule,
         );
@@ -177,6 +197,13 @@ fn execute_response_refunds_cycles() {
             consumed_cycles_after,
             consumed_cycles_before - response_transmission_refund.nominal(),
         );
+        assert_eq!(
+            consumed_cycles_after_counter,
+            consumed_cycles_before_counter
+                + (test.call_fee("update", &b_callback) + actual_response_transmission_fee)
+                    .nominal(),
+        );
+        assert_eq!(consumed_cycles_after, consumed_cycles_after_counter);
     }
 }
 

rs/execution_environment/src/execution_environment.rs

@@ -2178,8 +2178,11 @@ impl ExecutionEnvironment {
             state.metadata.subnet_call_context_manager.push_context(
                 SubnetCallContext::CanisterHttpRequest(canister_http_request_context),
             );
-            if let Some(canister_stats) = state.canister_state_make_mut(&request.sender) {
-                canister_stats
+            if let Some(canister_state) = state.canister_state_make_mut(&request.sender) {
+                canister_state
+                    .system_state
+                    .observe_consumed_cycles_for_https_outcall(nominal_http_request_fee);
+                canister_state
                     .system_state
                     .canister_metrics_mut()
                     .load_metrics_mut()