chore: add log

frontend/rust-lib/flowy-error/src/errors.rs

@@ -93,6 +93,8 @@ impl fmt::Display for FlowyError {
 impl lib_dispatch::Error for FlowyError {
     fn as_response(&self) -> EventResponse {
         let bytes: Bytes = self.clone().try_into().unwrap();
+
+        println!("Serialize FlowyError: {:?} to event response", self);
         ResponseBuilder::Err().data(bytes).build()
     }
 }

frontend/rust-lib/flowy-folder/src/services/app/controller.rs

@@ -68,7 +68,9 @@ impl AppController {
                 let app = transaction.read_app(&params.value)?;
                 let trash_ids = self.trash_controller.read_trash_ids(&transaction)?;
                 if trash_ids.contains(&app.id) {
-                    return Err(FlowyError::record_not_found());
+                    return Err(
+                        FlowyError::record_not_found().context(format!("Can not find the app:{}", params.value))
+                    );
                 }
                 Ok(app)
             })

frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs

@@ -44,7 +44,7 @@ pub(crate) async fn update_app_handler(
     Ok(())
 }
 
-#[tracing::instrument(level = "trace", skip(data, app_controller, view_controller))]
+#[tracing::instrument(level = "info", skip(data, app_controller, view_controller), err)]
 pub(crate) async fn read_app_handler(
     data: Data<AppIdPB>,
     app_controller: AppData<Arc<AppController>>,

frontend/rust-lib/flowy-test/src/event_builder.rs

@@ -83,15 +83,21 @@ where
         R: FromBytes,
     {
         let response = self.get_response();
-        match response.parse::<R, E>() {
+        match response.clone().parse::<R, E>() {
             Ok(Ok(data)) => data,
             Ok(Err(e)) => {
-                panic!("Parser {:?} failed: {:?}", std::any::type_name::<R>(), e)
+                panic!(
+                    "Parser {:?} failed: {:?}, response {:?}",
+                    std::any::type_name::<R>(),
+                    e,
+                    response
+                )
             }
             Err(e) => panic!(
-                "Internal error: {:?}, parser {:?} failed",
+                "Dispatch {:?} failed: {:?}, response {:?}",
-                e,
                 std::any::type_name::<R>(),
+                e,
+                response
             ),
         }
     }

frontend/rust-lib/flowy-user/src/services/database.rs

@@ -37,8 +37,8 @@ impl UserDB {
             Some(database) => return Ok(database.get_pool()),
         }
 
-        tracing::trace!("open user db {}", user_id);
         let dir = format!("{}/{}", self.db_dir, user_id);
+        tracing::trace!("open user db {} at path: {}", user_id, dir);
         let db = flowy_database::init(&dir).map_err(|e| {
             log::error!("open user: {} db failed, {:?}", user_id, e);
             FlowyError::internal().context(e)

frontend/rust-lib/lib-dispatch/src/byte_trait.rs

@@ -14,7 +14,12 @@ where
     fn into_bytes(self) -> Result<Bytes, DispatchError> {
         match self.try_into() {
             Ok(data) => Ok(data),
-            Err(e) => Err(InternalError::ProtobufError(format!("{:?}", e)).into()),
+            Err(e) => Err(InternalError::ProtobufError(format!(
+                "Serial {:?} to bytes failed:{:?}",
+                std::any::type_name::<T>(),
+                e
+            ))
+            .into()),
         }
     }
 }

frontend/rust-lib/lib-dispatch/src/data.rs

@@ -55,7 +55,10 @@ where
 {
     fn respond_to(self, _request: &EventRequest) -> EventResponse {
         match self.into_inner().into_bytes() {
-            Ok(bytes) => ResponseBuilder::Ok().data(bytes).build(),
+            Ok(bytes) => {
+                log::trace!("Serialize Data: {:?} to event response", std::any::type_name::<T>());
+                return ResponseBuilder::Ok().data(bytes).build();
+            }
             Err(e) => e.into(),
         }
     }
@@ -86,7 +89,11 @@ where
     T: FromBytes,
 {
     match payload {
-        Payload::None => Err(InternalError::UnexpectedNone("Parse fail, expected payload".to_string()).into()),
+        Payload::None => Err(InternalError::UnexpectedNone(format!(
+            "Parse fail, expected payload:{:?}",
+            std::any::type_name::<T>()
+        ))
+        .into()),
         Payload::Bytes(bytes) => {
             let data = T::parse_from_bytes(bytes.clone())?;
             Ok(Data(data))

frontend/rust-lib/lib-dispatch/src/dispatcher.rs

@@ -54,16 +54,18 @@ impl EventDispatcher {
             callback: Some(Box::new(callback)),
         };
         let join_handle = dispatch.runtime.spawn(async move {
-            service
+            service.call(service_ctx).await.unwrap_or_else(|e| {
-                .call(service_ctx)
+                tracing::error!("Dispatch runtime error: {:?}", e);
-                .await
+                InternalError::Other(format!("{:?}", e)).as_response()
-                .unwrap_or_else(|e| InternalError::Other(format!("{:?}", e)).as_response())
+            })
         });
 
         DispatchFuture {
             fut: Box::pin(async move {
                 join_handle.await.unwrap_or_else(|e| {
-                    let error = InternalError::JoinError(format!("EVENT_DISPATCH join error: {:?}", e));
+                    let msg = format!("EVENT_DISPATCH join error: {:?}", e);
+                    tracing::error!("{}", msg);
+                    let error = InternalError::JoinError(msg);
                     error.as_response()
                 })
             }),