Feat(node/service): Derivation Resets

=====================================================

Description

The DerivationActor plays a crucial role in the derivation pipeline, responsible for producing safe payload attributes. However, when certain events occur, the pipeline needs to be reset. This is indicated by the pipeline's step method returning a ResetError. In this feature, we aim to add metrics to the DerivationActor that records the number of resets for each reset type, which is a variant of the ResetError.

Problem Statement

The current implementation of the DerivationActor does not provide any insights into the number of resets that occur during the derivation pipeline. This lack of visibility makes it challenging to identify and troubleshoot issues related to the pipeline's behavior. By introducing metrics to track reset events, we can gain a better understanding of the pipeline's performance and make data-driven decisions to improve its reliability.

Solution Overview

To address the problem statement, we propose the following solution:

1. Mark ResetError with AsRefStr: We will modify the ResetError type to implement the AsRefStr trait, which allows us to convert the error variant to a string representation. This will enable us to use the error variant as a label value in the metric gauge.
2. Add metrics to DerivationActor: We will introduce a new metric gauge to the DerivationActor that records the number of resets for each reset type. The metric gauge will be configured to use the error variant as a label value, allowing us to track resets for each specific error type.
3. Implement reset event handling: We will modify the DerivationActor to handle reset events by incrementing the corresponding metric gauge for each reset type.

Implementation Details

To implement the solution, we will follow these steps:

Step 1: Mark ResetError with AsRefStr

We will modify the ResetError type to implement the AsRefStr trait using the strum_macros crate. This will allow us to convert the error variant to a string representation.

use strum_macros::AsRefStr;

#[derive(Debug, AsRefStr)]
enum ResetError {
    // ...
}

Step 2: Add metrics to DerivationActor

We will introduce a new metric gauge to the DerivationActor using the metrics crate. The metric gauge will be configured to use the error variant as a label value, allowing us to track resets for each specific error type.

use metrics::{gauge, Counter};

struct DerivationActor {
    // ...
    reset_errors: Counter,
}

impl DerivationActor {
    fn new() -> Self {
        // ...
        Self {
            reset_errors: Counter::new("derivation_actor.reset_errors", "Number of resets for each reset type"),
        }
    }

    fn step(&self, event: Event) -> Result<(), ResetError> {
        // ...
        match event {
            Event::Reset(error) => {
                self.reset_errors.increment(error.as_str());
                Err(error)
            }
            // ...
        }
    }
}

Step 3: Implement reset event handling

We will modify the DerivationActor to handle reset events by incrementing the corresponding metric gauge for reset type.

impl DerivationActor {
    fn handle_reset(&self, error: ResetError) {
        self.reset_errors.increment(error.as_str());
    }
}

Example Use Case

To demonstrate the usage of the DerivationActor with metrics, we will create a simple example that simulates a derivation pipeline with reset events.

fn main() {
    let actor = DerivationActor::new();
    let events = vec![
        Event::Reset(ResetError::Variant1),
        Event::Reset(ResetError::Variant2),
        Event::Reset(ResetError::Variant1),
    ];

    for event in events {
        match actor.step(event) {
            Ok(_) => {}
            Err(error) => actor.handle_reset(error),
        }
    }

    println!("Reset errors:");
    println!("  Variant1: {}", actor.reset_errors.get("Variant1"));
    println!("  Variant2: {}", actor.reset_errors.get("Variant2"));
}

In this example, we create a DerivationActor instance and simulate a derivation pipeline with three reset events. We then print the number of resets for each reset type using the get method of the Counter gauge.

Conclusion

In this feature, we have introduced metrics to the DerivationActor to track the number of resets for each reset type. By implementing the AsRefStr trait for the ResetError type and adding a metric gauge to the DerivationActor, we have gained visibility into the pipeline's behavior and can make data-driven decisions to improve its reliability. The example use case demonstrates the usage of the DerivationActor with metrics and shows how to track reset events in a derivation pipeline.

=====================================

Frequently Asked Questions

Q: What is the purpose of the DerivationActor in the node/service?

A: The DerivationActor plays a crucial role in the derivation pipeline, responsible for producing safe payload attributes. It steps over the derivation pipeline to produce (safe) payload attributes.

Q: What is a ResetError?

A: A ResetError is an error type that is returned by the pipeline's step method when certain events occur, indicating that the pipeline needs to be reset.

Q: Why do we need to mark ResetError with AsRefStr?

A: We need to mark ResetError with AsRefStr so that we can convert the error variant to a string representation, which is required for using the error variant as a label value in the metric gauge.

Q: What is the purpose of the metric gauge in the DerivationActor?

A: The metric gauge in the DerivationActor is used to track the number of resets for each reset type. It allows us to gain visibility into the pipeline's behavior and make data-driven decisions to improve its reliability.

Q: How do we implement reset event handling in the DerivationActor?

A: We implement reset event handling in the DerivationActor by incrementing the corresponding metric gauge for each reset type. This is done by calling the increment method of the Counter gauge with the error variant as a label value.

Q: What is the example use case for the DerivationActor with metrics?

A: The example use case demonstrates the usage of the DerivationActor with metrics by simulating a derivation pipeline with reset events and printing the number of resets for each reset type.

Q: How do we get the number of resets for each reset type using the metric gauge?

A: We get the number of resets for each reset type using the get method of the Counter gauge, passing in the error variant as a label value.

Q: What are the benefits of introducing metrics to the DerivationActor?

A: The benefits of introducing metrics to the DerivationActor include gaining visibility into the pipeline's behavior, making data-driven decisions to improve its reliability, and identifying and troubleshooting issues related to the pipeline's behavior.

Q: How do we troubleshoot issues related to the pipeline's behavior using the metric gauge?

A: We troubleshoot issues related to the pipeline's behavior using the metric gauge by analyzing the number of resets for each reset type and identifying any patterns or anomalies in the data.

Q: Can we use the metric gauge to track other types of events in the pipeline?

A: Yes, we can use the metric gauge to track other types of events in the pipeline by modifying the DerivationActor to increment the corresponding metric gauge for each event type.

Q: How do we configure the metric gauge to use the error variant as a label value?

A: We configure the metric gauge to use the error variant as a label value by passing the error variant as an argument to the increment method of the Counter gauge.

Q: What is the impact of introducing metrics to the DerivationActor on the pipeline's performance?

A: The impact of introducing metrics to the DerivationActor on the pipeline's performance is minimal, as the metric gauge only increments the corresponding counter for each reset type, without affecting the pipeline's execution flow.