tmp

Author: tizoc

node/common/src/service/block_producer/mod.rs

@@ -130,6 +130,7 @@ fn prover_loop(
                 }
             }
         }
+        // TODO: error must include the input
         let res = res.map_err(|err| err.to_string());
         let _ = event_sender.send(BlockProducerEvent::BlockProve(block_hash, res).into());
     }

node/common/src/service/service.rs

@@ -187,6 +187,14 @@ impl redux::TimeService for NodeService {
     }
 }
 
+impl node::service::ErrorSinkService for NodeService {
+    fn submit_error_report_data(&mut self, category: &str, data: Vec<u8>) {
+        let _ = category;
+        let _ = data;
+        todo!()
+    }
+}
+
 impl node::service::EventSourceService for NodeService {
     fn next_event(&mut self) -> Option<Event> {
         self.event_receiver.try_next()

node/src/block_producer/block_producer_reducer.rs

@@ -310,6 +310,9 @@ impl BlockProducerEnabled {
                 dispatcher.push(BlockProducerEffectfulAction::BlockProveError {
                     error: error.clone(),
                 });
+                dispatcher.push(BlockProducerAction::WonSlotDiscard {
+                    reason: super::BlockProducerWonSlotDiscardReason::BlockProofError,
+                });
             }
             BlockProducerAction::BlockProduced => {
                 let current_state = std::mem::take(&mut state.current);

node/src/block_producer/block_producer_state.rs

@@ -149,6 +149,7 @@ pub enum BlockProducerWonSlotDiscardReason {
     BestTipStakingLedgerDifferent,
     BestTipGlobalSlotHigher,
     BestTipSuperior,
+    BlockProofError,
 }
 
 impl BlockProducerState {

node/src/block_producer_effectful/block_producer_effectful_effects.rs

@@ -216,12 +216,7 @@ pub fn block_producer_effects<S: crate::Service>(
             store.dispatch(BlockProducerAction::BlockProduced);
         }
         BlockProducerEffectfulAction::BlockProveError { error } => {
-            if let Some(stats) = store.service.stats() {
-                stats
-                    .block_producer()
-                    .proof_create_error(meta.time(), error.clone());
-            }
-            store.dispatch(BlockProducerAction::BlockProveError { error });
+            store.service.submit_error_report("blockProofFailure", error);
         }
         BlockProducerEffectfulAction::WonSlotDiscard { reason } => {
             if let Some(stats) = store.service.stats() {

node/src/lib.rs

@@ -35,6 +35,7 @@ pub mod stats;
 pub mod block_producer;
 pub mod block_producer_effectful;
 pub mod daemon_json;
+pub mod error_sink;
 pub mod event_source;
 pub mod external_snark_worker;
 pub mod external_snark_worker_effectful;

node/src/service.rs

@@ -1,5 +1,6 @@
 pub use crate::block_producer_effectful::vrf_evaluator_effectful::BlockProducerVrfEvaluatorService;
 pub use crate::block_producer_effectful::BlockProducerService;
+pub use crate::error_sink::ErrorSinkService;
 pub use crate::event_source::EventSourceService;
 pub use crate::external_snark_worker_effectful::ExternalSnarkWorkerService;
 pub use crate::ledger::LedgerService;
@@ -33,6 +34,7 @@ pub trait Service:
     + ExternalSnarkWorkerService
     + RpcService
     + ArchiveService
+    + ErrorSinkService
 {
     fn queues(&mut self) -> Queues;
     fn stats(&mut self) -> Option<&mut Stats>;

node/src/stats/stats_block_producer.rs

@@ -45,7 +45,6 @@ pub struct BlockProductionTimes {
     pub produced: Option<redux::Timestamp>,
     pub proof_create_start: Option<redux::Timestamp>,
     pub proof_create_end: Option<redux::Timestamp>,
-    pub proof_create_error: Option<redux::Timestamp>,
     pub block_apply_start: Option<redux::Timestamp>,
     pub block_apply_end: Option<redux::Timestamp>,
     pub committed: Option<redux::Timestamp>,
@@ -61,9 +60,6 @@ pub enum BlockProductionStatus {
     Produced,
     ProofCreatePending,
     ProofCreateSuccess,
-    ProofCreateError {
-        error: String,
-    },
     BlockApplyPending,
     BlockApplySuccess,
     Committed,
@@ -205,7 +201,6 @@ impl BlockProducerStats {
                 produced: None,
                 proof_create_start: None,
                 proof_create_end: None,
-                proof_create_error: None,
                 block_apply_start: None,
                 block_apply_end: None,
                 committed: None,
@@ -282,17 +277,6 @@ impl BlockProducerStats {
         });
     }
 
-    pub fn proof_create_error(&mut self, time: redux::Timestamp, error: String) {
-        self.update("proof_create_error", move |attempt| match attempt.status {
-            BlockProductionStatus::ProofCreatePending => {
-                attempt.status = BlockProductionStatus::ProofCreateError { error };
-                attempt.times.proof_create_error = Some(time);
-                true
-            }
-            _ => false,
-        });
-    }
-
     pub fn block_apply_start(&mut self, time: redux::Timestamp, hash: &BlockHash) {
         if !self.is_our_just_produced_block(hash) {
             return;

node/testing/src/service/mod.rs

@@ -340,6 +340,12 @@ impl redux::TimeService for NodeTestingService {
     }
 }
 
+impl node::service::ErrorSinkService for NodeTestingService {
+    fn submit_error_report_data(&mut self, _category: &str, _data: Vec<u8>) {
+        // TODO: log or store on disk?
+    }
+}
+
 impl node::event_source::EventSourceService for NodeTestingService {
     fn next_event(&mut self) -> Option<Event> {
         None

tools/error-sink-service/src/main.rs

@@ -2,7 +2,7 @@ use actix_web::middleware::{DefaultHeaders, Logger};
 use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Result};
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
 use chrono::Utc;
-use log::{error, info, warn};
+use log::{error, info};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::fs::{self, File};