fix: simplify the shutdown reason due to the memory limit of the event record (#367)

* fix: simplify the shutdown reason due to the memory limit of the event record

* chore: remove an unused dependency

* chore: update `Cargo.lock`

Author: nyannyacha

Cargo.lock

@@ -79,7 +79,6 @@ glob = "0.3.1"
 httparse = "1.8"
 http = "0.2"
 faster-hex = "0.9.0"
-strum = "0.25"
 
 # DEBUG
 # [patch.crates-io]

Cargo.toml

@@ -6,7 +6,6 @@ use std::sync::Arc;
 use cpu_timer::{CPUAlarmVal, CPUTimer};
 use deno_core::v8::IsolateHandle;
 use enum_as_inner::EnumAsInner;
-use event_worker::events::MemoryLimitDetail;
 use futures_util::task::AtomicWaker;
 use log::error;
 use sb_workers::context::{Timing, UserWorkerMsgs, UserWorkerRuntimeOpts};
@@ -127,7 +126,7 @@ pub struct Arguments {
     pub cpu_timer_param: CPUTimerParam,
     pub supervisor_policy: SupervisorPolicy,
     pub timing: Option<Timing>,
-    pub memory_limit_rx: mpsc::UnboundedReceiver<MemoryLimitDetail>,
+    pub memory_limit_rx: mpsc::UnboundedReceiver<()>,
     pub pool_msg_tx: Option<mpsc::UnboundedSender<UserWorkerMsgs>>,
     pub isolate_memory_usage_tx: oneshot::Sender<IsolateMemoryStats>,
     pub thread_safe_handle: IsolateHandle,

crates/base/src/rt_worker/supervisor/mod.rs

@@ -176,9 +176,9 @@ pub async fn supervise(args: Arguments, oneshot: bool) -> (ShutdownReason, i64)
                 }
             }
 
-            Some(detail) = memory_limit_rx.recv() => {
+            Some(_) = memory_limit_rx.recv() => {
                 error!("memory limit reached for the worker: isolate: {:?}", key);
-                complete_reason = Some(ShutdownReason::Memory(detail));
+                complete_reason = Some(ShutdownReason::Memory);
             }
         }
 

crates/base/src/rt_worker/supervisor/strategy_per_request.rs

@@ -208,11 +208,10 @@ pub async fn supervise(args: Arguments) -> (ShutdownReason, i64) {
                 }
             }
 
-            // memory usage
-            Some(detail) = memory_limit_rx.recv() => {
+            Some(_) = memory_limit_rx.recv() => {
                 terminate_fn();
                 error!("memory limit reached for the worker: isolate: {:?}", key);
-                return (ShutdownReason::Memory(detail), cpu_usage_ms);
+                return (ShutdownReason::Memory, cpu_usage_ms);
             }
         }
     }

crates/base/src/rt_worker/supervisor/strategy_per_worker.rs

@@ -11,8 +11,7 @@ use cpu_timer::CPUTimer;
 use deno_config::JsxImportSourceConfig;
 use deno_core::{InspectorSessionProxy, LocalInspectorSession};
 use event_worker::events::{
-    BootEvent, MemoryLimitDetail, ShutdownEvent, WorkerEventWithMetadata, WorkerEvents,
-    WorkerMemoryUsed,
+    BootEvent, ShutdownEvent, WorkerEventWithMetadata, WorkerEvents, WorkerMemoryUsed,
 };
 use futures_util::pin_mut;
 use http::StatusCode;
@@ -261,7 +260,7 @@ pub fn create_supervisor(
     timing: Option<Timing>,
     termination_token: Option<TerminationToken>,
 ) -> Result<(Option<CPUTimer>, CancellationToken), Error> {
-    let (memory_limit_tx, memory_limit_rx) = mpsc::unbounded_channel::<MemoryLimitDetail>();
+    let (memory_limit_tx, memory_limit_rx) = mpsc::unbounded_channel();
     let (waker, thread_safe_handle) = {
         let js_runtime = &mut worker_runtime.js_runtime;
         (
@@ -294,32 +293,29 @@ pub fn create_supervisor(
         )
     });
 
-    let send_memory_limit_fn = move |detail: MemoryLimitDetail| {
-        debug!(
-            "memory limit triggered: isolate: {:?}, detail: {:?}",
-            key, detail
-        );
+    let send_memory_limit_fn = move |kind: &'static str| {
+        debug!("memory limit triggered: isolate: {:?}, kind: {}", key, kind);
 
-        if memory_limit_tx.send(detail).is_err() {
+        if memory_limit_tx.send(()).is_err() {
             error!(
-                "failed to send memory limit reached notification - isolate may already be terminating: kind: {}",
-                <&'static str>::from(&detail)
+                "failed to send memory limit reached notification(isolate may already be terminating): isolate: {:?}, kind: {}",
+                key, kind
             );
         }
     };
 
     worker_runtime.add_memory_limit_callback({
         let send_fn = send_memory_limit_fn.clone();
         move |_| {
-            send_fn(MemoryLimitDetail::MemCheck);
+            send_fn("mem_check");
             true
         }
     });
 
     worker_runtime.js_runtime.add_near_heap_limit_callback({
         let send_fn = send_memory_limit_fn;
         move |current, _| {
-            send_fn(MemoryLimitDetail::V8);
+            send_fn("v8");
 
             // give an allowance on current limit (until the isolate is
             // terminated) we do this so that oom won't end up killing the

crates/base/src/rt_worker/worker_ctx.rs

@@ -17,5 +17,4 @@ uuid.workspace = true
 serde.workspace = true
 anyhow.workspace = true
 tokio.workspace = true
-log.workspace = true
-strum = { workspace = true, features = ["derive"] }
+log.workspace = true

crates/event_worker/Cargo.toml

@@ -1,6 +1,5 @@
 use base_mem_check::MemCheckState;
 use serde::{Deserialize, Serialize};
-use strum::IntoStaticStr;
 use uuid::Uuid;
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -20,20 +19,11 @@ pub struct WorkerMemoryUsed {
     pub mem_check_captured: MemCheckState,
 }
 
-#[derive(Serialize, Deserialize, IntoStaticStr, Debug, Clone, Copy)]
-#[serde(tag = "limited_by")]
-#[serde(rename_all = "snake_case")]
-#[strum(serialize_all = "snake_case")]
-pub enum MemoryLimitDetail {
-    MemCheck,
-    V8,
-}
-
 #[derive(Serialize, Deserialize, Debug)]
 pub enum ShutdownReason {
     WallClockTime,
     CPUTime,
-    Memory(MemoryLimitDetail),
+    Memory,
     EarlyDrop,
     TerminationRequested,
 }