Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

[rust]: replace log with tracing

Browse Source
This commit is contained in:
appflowy 2021-11-03 15:37:38 +08:00
parent 7ad0060d8b
commit ffd55763b6
34 changed files with 91 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
backend/src/middleware/auth_middleware.rs
View File

@ -54,7 +54,7 @@ where
fn call(&self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
let mut authenticate_pass: bool = false; let mut authenticate_pass: bool = false;
for ignore_route in IGNORE_ROUTES.iter() { for ignore_route in IGNORE_ROUTES.iter() {
// log::info!("ignore: {}, path: {}", ignore_route, req.path()); // tracing::info!("ignore: {}, path: {}", ignore_route, req.path());
if req.path().starts_with(ignore_route) { if req.path().starts_with(ignore_route) {
authenticate_pass = true; authenticate_pass = true;
break; break;
@ -79,7 +79,7 @@ where
Err(e) => log::error!("{:?}", e), Err(e) => log::error!("{:?}", e),
} }
} else { } else {
log::debug!("Can't find any token from request: {:?}", req); tracing::debug!("Can't find any token from request: {:?}", req);
} }
} }

4
backend/src/service/user/logged_user.rs
View File

@ -82,7 +82,7 @@ impl AuthorizedUsers {
pub fn is_authorized(&self, user: &LoggedUser) -> bool { pub fn is_authorized(&self, user: &LoggedUser) -> bool {
match self.0.get(user) { match self.0.get(user) {
None => { None => {
log::debug!("user not login yet or server was reboot"); tracing::debug!("user not login yet or server was reboot");
false false
}, },
Some(status) => match *status { Some(status) => match *status {
@ -92,7 +92,7 @@ impl AuthorizedUsers {
days < EXPIRED_DURATION_DAYS days < EXPIRED_DURATION_DAYS
}, },
AuthStatus::NotAuthorized => { AuthStatus::NotAuthorized => {
log::debug!("user logout already"); tracing::debug!("user logout already");
false false
}, },
}, },

2
backend/src/service/ws/router.rs
View File

@ -20,7 +20,7 @@ pub async fn establish_ws_connection(
server: Data<Addr<WsServer>>, server: Data<Addr<WsServer>>,
biz_handlers: Data<WsBizHandlers>, biz_handlers: Data<WsBizHandlers>,
) -> Result<HttpResponse, Error> { ) -> Result<HttpResponse, Error> {
log::info!("establish_ws_connection"); tracing::info!("establish_ws_connection");
match LoggedUser::from_token(token.clone()) { match LoggedUser::from_token(token.clone()) {
Ok(user) => { Ok(user) => {
let ws_user = WsUser::new(user.clone()); let ws_user = WsUser::new(user.clone());

4
backend/src/service/ws/ws_client.rs
View File

@ -91,7 +91,7 @@ impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WsClient {
ctx.pong(&msg); ctx.pong(&msg);
}, },
Ok(ws::Message::Pong(_msg)) => { Ok(ws::Message::Pong(_msg)) => {
// log::debug!("Receive {} pong {:?}", &self.session_id, &msg); // tracing::debug!("Receive {} pong {:?}", &self.session_id, &msg);
self.hb = Instant::now(); self.hb = Instant::now();
}, },
Ok(ws::Message::Binary(bytes)) => { Ok(ws::Message::Binary(bytes)) => {
@ -136,7 +136,7 @@ impl Actor for WsClient {
.into_actor(self) .into_actor(self)
.then(|res, _client, _ctx| { .then(|res, _client, _ctx| {
match res { match res {
Ok(Ok(_)) => log::trace!("Send connect message to server success"), Ok(Ok(_)) => tracing::trace!("Send connect message to server success"),
Ok(Err(e)) => log::error!("Send connect message to server failed: {:?}", e), Ok(Err(e)) => log::error!("Send connect message to server failed: {:?}", e),
Err(e) => log::error!("Send connect message to server failed: {:?}", e), Err(e) => log::error!("Send connect message to server failed: {:?}", e),
} }

4
backend/tests/api/auth.rs
View File

@ -5,7 +5,7 @@ use flowy_user::entities::{SignInParams, SignUpParams, SignUpResponse, UpdateUse
async fn user_register() { async fn user_register() {
let app = spawn_user_server().await; let app = spawn_user_server().await;
let response = register_user(&app, "annie@appflowy.io", "HelloWorld123!").await; let response = register_user(&app, "annie@appflowy.io", "HelloWorld123!").await;
log::info!("{:?}", response); tracing::info!("{:?}", response);
} }
#[actix_rt::test] #[actix_rt::test]
@ -52,7 +52,7 @@ async fn user_sign_out() {
#[actix_rt::test] #[actix_rt::test]
async fn user_get_detail() { async fn user_get_detail() {
let server = TestUserServer::new().await; let server = TestUserServer::new().await;
log::info!("{:?}", server.get_user_profile().await); tracing::info!("{:?}", server.get_user_profile().await);
} }
#[actix_rt::test] #[actix_rt::test]

8
backend/tests/api/workspace.rs
View File

@ -9,14 +9,14 @@ use flowy_workspace::entities::{
#[actix_rt::test] #[actix_rt::test]
async fn workspace_create() { async fn workspace_create() {
let test = WorkspaceTest::new().await; let test = WorkspaceTest::new().await;
log::info!("{:?}", test.workspace); tracing::info!("{:?}", test.workspace);
} }
#[actix_rt::test] #[actix_rt::test]
async fn workspace_read() { async fn workspace_read() {
let test = WorkspaceTest::new().await; let test = WorkspaceTest::new().await;
let read_params = QueryWorkspaceParams::new().workspace_id(&test.workspace.id); let read_params = QueryWorkspaceParams::new().workspace_id(&test.workspace.id);
log::info!("{:?}", test.server.read_workspaces(read_params).await); tracing::info!("{:?}", test.server.read_workspaces(read_params).await);
} }
#[actix_rt::test] #[actix_rt::test]
@ -69,7 +69,7 @@ async fn workspace_delete() {
#[actix_rt::test] #[actix_rt::test]
async fn app_create() { async fn app_create() {
let test = AppTest::new().await; let test = AppTest::new().await;
log::info!("{:?}", test.app); tracing::info!("{:?}", test.app);
} }
#[actix_rt::test] #[actix_rt::test]
@ -134,7 +134,7 @@ async fn app_delete() {
#[actix_rt::test] #[actix_rt::test]
async fn view_create() { async fn view_create() {
let test = ViewTest::new().await; let test = ViewTest::new().await;
log::info!("{:?}", test.view); tracing::info!("{:?}", test.view);
} }
#[actix_rt::test] #[actix_rt::test]

8
rust-lib/flowy-dispatch/src/dispatch.rs
View File

@ -23,7 +23,7 @@ impl EventDispatch {
{ {
let runtime = tokio_default_runtime().unwrap(); let runtime = tokio_default_runtime().unwrap();
let modules = module_factory(); let modules = module_factory();
log::trace!("{}", module_info(&modules)); tracing::trace!("{}", module_info(&modules));
let module_map = as_module_map(modules); let module_map = as_module_map(modules);
let dispatch = EventDispatch { module_map, runtime }; let dispatch = EventDispatch { module_map, runtime };
@ -49,7 +49,7 @@ impl EventDispatch {
let request: ModuleRequest = request.into(); let request: ModuleRequest = request.into();
let module_map = dispatch.module_map.clone(); let module_map = dispatch.module_map.clone();
let service = Box::new(DispatchService { module_map }); let service = Box::new(DispatchService { module_map });
log::trace!("Async event: {:?}", &request.event); tracing::trace!("Async event: {:?}", &request.event);
let service_ctx = DispatchContext { let service_ctx = DispatchContext {
request, request,
callback: Some(Box::new(callback)), callback: Some(Box::new(callback)),
@ -157,7 +157,7 @@ impl Service<DispatchContext> for DispatchService {
}; };
let response = result.unwrap_or_else(|e| e.into()); let response = result.unwrap_or_else(|e| e.into());
log::trace!("Dispatch result: {:?}", response); tracing::trace!("Dispatch result: {:?}", response);
if let Some(callback) = callback { if let Some(callback) = callback {
callback(response.clone()).await; callback(response.clone()).await;
} }
@ -179,6 +179,6 @@ fn module_info(modules: &Vec<Module>) -> String {
#[allow(dead_code)] #[allow(dead_code)]
fn print_module_map_info(module_map: &ModuleMap) { fn print_module_map_info(module_map: &ModuleMap) {
module_map.iter().for_each(|(k, v)| { module_map.iter().for_each(|(k, v)| {
log::info!("Event: {:?} module: {:?}", k, v.name); tracing::info!("Event: {:?} module: {:?}", k, v.name);
}) })
} }

2
rust-lib/flowy-dispatch/src/module/module.rs
View File

@ -228,7 +228,7 @@ impl Future for ModuleServiceFuture {
// //
// match sys_rx.recv().await { // match sys_rx.recv().await {
// Some(cmd) => { // Some(cmd) => {
// log::info!("{:?}", cmd); // tracing::info!("{:?}", cmd);
// }, // },
// None => panic!(""), // None => panic!(""),
// } // }

4
rust-lib/flowy-dispatch/src/util/mod.rs
View File

@ -10,14 +10,14 @@ pub fn tokio_default_runtime() -> io::Result<tokio::runtime::Runtime> {
.enable_io() .enable_io()
.enable_time() .enable_time()
.on_thread_start(move || { .on_thread_start(move || {
log::trace!( tracing::trace!(
"{:?} thread started: thread_id= {}", "{:?} thread started: thread_id= {}",
thread::current(), thread::current(),
thread_id::get() thread_id::get()
); );
}) })
.on_thread_stop(move || { .on_thread_stop(move || {
log::trace!( tracing::trace!(
"{:?} thread stopping: thread_id= {}", "{:?} thread stopping: thread_id= {}",
thread::current(), thread::current(),
thread_id::get(), thread_id::get(),

24
rust-lib/flowy-document/src/services/doc/document/document.rs
View File

@ -68,28 +68,28 @@ impl Document {
} }
pub fn compose_delta(&mut self, delta: &Delta) -> Result<(), DocError> { pub fn compose_delta(&mut self, delta: &Delta) -> Result<(), DocError> {
log::trace!("{} compose {}", &self.delta.to_json(), delta.to_json()); tracing::trace!("{} compose {}", &self.delta.to_json(), delta.to_json());
let composed_delta = self.delta.compose(delta)?; let composed_delta = self.delta.compose(delta)?;
let mut undo_delta = delta.invert(&self.delta); let mut undo_delta = delta.invert(&self.delta);
let now = chrono::Utc::now().timestamp_millis() as usize; let now = chrono::Utc::now().timestamp_millis() as usize;
if now - self.last_edit_time < RECORD_THRESHOLD { if now - self.last_edit_time < RECORD_THRESHOLD {
if let Some(last_delta) = self.history.undo() { if let Some(last_delta) = self.history.undo() {
log::trace!("compose previous change"); tracing::trace!("compose previous change");
log::trace!("current = {}", undo_delta); tracing::trace!("current = {}", undo_delta);
log::trace!("previous = {}", last_delta); tracing::trace!("previous = {}", last_delta);
undo_delta = undo_delta.compose(&last_delta)?; undo_delta = undo_delta.compose(&last_delta)?;
} }
} else { } else {
self.last_edit_time = now; self.last_edit_time = now;
} }
log::trace!("👉 receive change undo: {}", undo_delta); tracing::trace!("👉 receive change undo: {}", undo_delta);
if !undo_delta.is_empty() { if !undo_delta.is_empty() {
self.history.record(undo_delta); self.history.record(undo_delta);
} }
log::trace!("compose result: {}", composed_delta.to_json()); tracing::trace!("compose result: {}", composed_delta.to_json());
self.set_delta(composed_delta); self.set_delta(composed_delta);
Ok(()) Ok(())
} }
@ -100,7 +100,7 @@ impl Document {
let text = data.to_string(); let text = data.to_string();
let delta = self.view.insert(&self.delta, &text, interval)?; let delta = self.view.insert(&self.delta, &text, interval)?;
log::trace!("👉 receive change: {}", delta); tracing::trace!("👉 receive change: {}", delta);
self.compose_delta(&delta)?; self.compose_delta(&delta)?;
Ok(delta) Ok(delta)
} }
@ -110,7 +110,7 @@ impl Document {
debug_assert_eq!(interval.is_empty(), false); debug_assert_eq!(interval.is_empty(), false);
let delete = self.view.delete(&self.delta, interval)?; let delete = self.view.delete(&self.delta, interval)?;
if !delete.is_empty() { if !delete.is_empty() {
log::trace!("👉 receive change: {}", delete); tracing::trace!("👉 receive change: {}", delete);
let _ = self.compose_delta(&delete)?; let _ = self.compose_delta(&delete)?;
} }
Ok(delete) Ok(delete)
@ -118,10 +118,10 @@ impl Document {
pub fn format(&mut self, interval: Interval, attribute: Attribute) -> Result<Delta, DocError> { pub fn format(&mut self, interval: Interval, attribute: Attribute) -> Result<Delta, DocError> {
let _ = validate_interval(&self.delta, &interval)?; let _ = validate_interval(&self.delta, &interval)?;
log::trace!("format with {} at {}", attribute, interval); tracing::trace!("format with {} at {}", attribute, interval);
let format_delta = self.view.format(&self.delta, attribute.clone(), interval).unwrap(); let format_delta = self.view.format(&self.delta, attribute.clone(), interval).unwrap();
log::trace!("👉 receive change: {}", format_delta); tracing::trace!("👉 receive change: {}", format_delta);
self.compose_delta(&format_delta)?; self.compose_delta(&format_delta)?;
Ok(format_delta) Ok(format_delta)
} }
@ -132,7 +132,7 @@ impl Document {
let text = data.to_string(); let text = data.to_string();
if !text.is_empty() { if !text.is_empty() {
delta = self.view.insert(&self.delta, &text, interval)?; delta = self.view.insert(&self.delta, &text, interval)?;
log::trace!("👉 receive change: {}", delta); tracing::trace!("👉 receive change: {}", delta);
self.compose_delta(&delta)?; self.compose_delta(&delta)?;
} }
@ -182,7 +182,7 @@ impl Document {
// c = a.compose(b) // c = a.compose(b)
// d = b.invert(a) // d = b.invert(a)
// a = c.compose(d) // a = c.compose(d)
log::trace!("Invert {}", delta); tracing::trace!("Invert {}", delta);
let new_delta = self.delta.compose(delta)?; let new_delta = self.delta.compose(delta)?;
let inverted_delta = delta.invert(&self.delta); let inverted_delta = delta.invert(&self.delta);
Ok((new_delta, inverted_delta)) Ok((new_delta, inverted_delta))

4
rust-lib/flowy-document/src/services/doc/edit/doc_actor.rs
View File

@ -111,10 +111,10 @@ impl DocumentActor {
} }
async fn compose_delta(&self, delta: Delta) -> DocResult<()> { async fn compose_delta(&self, delta: Delta) -> DocResult<()> {
// log::debug!("{:?} thread handle_message", thread::current(),); // tracing::debug!("{:?} thread handle_message", thread::current(),);
let mut document = self.document.write().await; let mut document = self.document.write().await;
let result = document.compose_delta(&delta); let result = document.compose_delta(&delta);
log::debug!( tracing::debug!(
"Compose push delta: {}. result: {}", "Compose push delta: {}. result: {}",
delta.to_json(), delta.to_json(),
document.to_json() document.to_json()

2
rust-lib/flowy-document/src/services/doc/edit/edit_doc.rs
View File

@ -304,7 +304,7 @@ fn spawn_rev_receiver(mut receiver: mpsc::UnboundedReceiver<Revision>, ws: Arc<d
tokio::spawn(async move { tokio::spawn(async move {
loop { loop {
while let Some(revision) = receiver.recv().await { while let Some(revision) = receiver.recv().await {
log::debug!("Send revision:{} to server", revision.rev_id); tracing::debug!("Send revision:{} to server", revision.rev_id);
match ws.send(revision.into()) { match ws.send(revision.into()) {
Ok(_) => {}, Ok(_) => {},
Err(e) => log::error!("Send revision failed: {:?}", e), Err(e) => log::error!("Send revision failed: {:?}", e),

2
rust-lib/flowy-document/src/services/doc/revision/persistence.rs
View File

@ -219,7 +219,7 @@ async fn fetch_from_local(doc_id: &str, persistence: Arc<Persistence>) -> DocRes
// return; // return;
// } // }
// //
// log::debug!("Try to update {:?} state", rev_ids); // tracing::debug!("Try to update {:?} state", rev_ids);
// match self.update(&rev_ids) { // match self.update(&rev_ids) {
// Ok(_) => { // Ok(_) => {
// self.revs.retain(|k, _| !rev_ids.contains(k)); // self.revs.retain(|k, _| !rev_ids.contains(k));

6
rust-lib/flowy-document/src/services/doc/view.rs
View File

@ -25,7 +25,7 @@ impl View {
let mut new_delta = None; let mut new_delta = None;
for ext in &self.insert_exts { for ext in &self.insert_exts {
if let Some(delta) = ext.apply(delta, interval.size(), text, interval.start) { if let Some(delta) = ext.apply(delta, interval.size(), text, interval.start) {
log::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta); tracing::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta); new_delta = Some(delta);
break; break;
} }
@ -41,7 +41,7 @@ impl View {
let mut new_delta = None; let mut new_delta = None;
for ext in &self.delete_exts { for ext in &self.delete_exts {
if let Some(delta) = ext.apply(delta, interval) { if let Some(delta) = ext.apply(delta, interval) {
log::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta); tracing::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta); new_delta = Some(delta);
break; break;
} }
@ -57,7 +57,7 @@ impl View {
let mut new_delta = None; let mut new_delta = None;
for ext in &self.format_exts { for ext in &self.format_exts {
if let Some(delta) = ext.apply(delta, interval, &attribute) { if let Some(delta) = ext.apply(delta, interval, &attribute) {
log::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta); tracing::trace!("[{}]: applied, delta: {}", ext.ext_name(), delta);
new_delta = Some(delta); new_delta = Some(delta);
break; break;
} }

5
rust-lib/flowy-document/src/services/file/manager.rs
View File

@ -64,7 +64,7 @@ impl FileManager {
pub(crate) fn create_file(&mut self, id: &str, dir: &str, text: &str) -> Result<PathBuf, FileError> { pub(crate) fn create_file(&mut self, id: &str, dir: &str, text: &str) -> Result<PathBuf, FileError> {
let path = PathBuf::from(format!("{}/{}", dir, id)); let path = PathBuf::from(format!("{}/{}", dir, id));
let file_id: FileId = id.to_owned().into(); let file_id: FileId = id.to_owned().into();
log::info!("Create doc at: {:?}", path); tracing::info!("Create doc at: {:?}", path);
let _ = self.save_new(&path, text, &file_id)?; let _ = self.save_new(&path, text, &file_id)?;
Ok(path) Ok(path)
} }
@ -89,7 +89,8 @@ impl FileManager {
#[allow(dead_code)] #[allow(dead_code)]
fn save_new(&mut self, path: &Path, text: &str, id: &FileId) -> Result<(), FileError> { fn save_new(&mut self, path: &Path, text: &str, id: &FileId) -> Result<(), FileError> {
try_save(path, text, CharacterEncoding::Utf8, self.get_info(id)).map_err(|e| FileError::Io(e, path.to_owned()))?; try_save(path, text, CharacterEncoding::Utf8, self.get_info(id))
.map_err(|e| FileError::Io(e, path.to_owned()))?;
let info = FileInfo { let info = FileInfo {
encoding: CharacterEncoding::Utf8, encoding: CharacterEncoding::Utf8,
path: path.to_owned(), path: path.to_owned(),

4
rust-lib/flowy-document/src/sql_tables/doc/rev_sql.rs
View File

@ -23,7 +23,7 @@ impl RevTableSql {
let records = revisions let records = revisions
.into_iter() .into_iter()
.map(|(revision, new_state)| { .map(|(revision, new_state)| {
log::debug!("Set {} to {:?}", revision.rev_id, new_state); tracing::debug!("Set {} to {:?}", revision.rev_id, new_state);
let rev_ty: RevTableType = revision.ty.into(); let rev_ty: RevTableType = revision.ty.into();
( (
doc_id.eq(revision.doc_id), doc_id.eq(revision.doc_id),
@ -45,7 +45,7 @@ impl RevTableSql {
.filter(rev_id.eq(changeset.rev_id.as_ref())) .filter(rev_id.eq(changeset.rev_id.as_ref()))
.filter(doc_id.eq(changeset.doc_id)); .filter(doc_id.eq(changeset.doc_id));
let _ = update(filter).set(state.eq(changeset.state)).execute(conn)?; let _ = update(filter).set(state.eq(changeset.state)).execute(conn)?;
log::debug!("Set {} to {:?}", changeset.rev_id, changeset.state); tracing::debug!("Set {} to {:?}", changeset.rev_id, changeset.state);
Ok(()) Ok(())
} }

32
rust-lib/flowy-document/tests/editor/mod.rs
View File

@ -100,25 +100,25 @@ impl TestBuilder {
} }
fn run_op(&mut self, op: &TestOp) { fn run_op(&mut self, op: &TestOp) {
log::trace!("***************** 😈{} *******************", &op); tracing::trace!("***************** 😈{} *******************", &op);
match op { match op {
TestOp::Insert(delta_i, s, index) => { TestOp::Insert(delta_i, s, index) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let delta = document.insert(*index, s).unwrap(); let delta = document.insert(*index, s).unwrap();
log::debug!("Insert delta: {}", delta.to_json()); tracing::debug!("Insert delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Delete(delta_i, iv) => { TestOp::Delete(delta_i, iv) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let delta = document.replace(*iv, "").unwrap(); let delta = document.replace(*iv, "").unwrap();
log::trace!("Delete delta: {}", delta.to_json()); tracing::trace!("Delete delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Replace(delta_i, iv, s) => { TestOp::Replace(delta_i, iv, s) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let delta = document.replace(*iv, s).unwrap(); let delta = document.replace(*iv, s).unwrap();
log::trace!("Replace delta: {}", delta.to_json()); tracing::trace!("Replace delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::InsertBold(delta_i, s, iv) => { TestOp::InsertBold(delta_i, s, iv) => {
@ -130,7 +130,7 @@ impl TestBuilder {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let attribute = Attribute::Bold(*enable); let attribute = Attribute::Bold(*enable);
let delta = document.format(*iv, attribute).unwrap(); let delta = document.format(*iv, attribute).unwrap();
log::trace!("Bold delta: {}", delta.to_json()); tracing::trace!("Bold delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Italic(delta_i, iv, enable) => { TestOp::Italic(delta_i, iv, enable) => {
@ -140,28 +140,28 @@ impl TestBuilder {
false => Attribute::Italic(false), false => Attribute::Italic(false),
}; };
let delta = document.format(*iv, attribute).unwrap(); let delta = document.format(*iv, attribute).unwrap();
log::trace!("Italic delta: {}", delta.to_json()); tracing::trace!("Italic delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Header(delta_i, iv, level) => { TestOp::Header(delta_i, iv, level) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let attribute = Attribute::Header(*level); let attribute = Attribute::Header(*level);
let delta = document.format(*iv, attribute).unwrap(); let delta = document.format(*iv, attribute).unwrap();
log::trace!("Header delta: {}", delta.to_json()); tracing::trace!("Header delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Link(delta_i, iv, link) => { TestOp::Link(delta_i, iv, link) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let attribute = Attribute::Link(link.to_owned()); let attribute = Attribute::Link(link.to_owned());
let delta = document.format(*iv, attribute).unwrap(); let delta = document.format(*iv, attribute).unwrap();
log::trace!("Link delta: {}", delta.to_json()); tracing::trace!("Link delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
TestOp::Bullet(delta_i, iv, enable) => { TestOp::Bullet(delta_i, iv, enable) => {
let document = &mut self.documents[*delta_i]; let document = &mut self.documents[*delta_i];
let attribute = Attribute::Bullet(*enable); let attribute = Attribute::Bullet(*enable);
let delta = document.format(*iv, attribute).unwrap(); let delta = document.format(*iv, attribute).unwrap();
log::debug!("Bullet delta: {}", delta.to_json()); tracing::debug!("Bullet delta: {}", delta.to_json());
self.deltas.insert(*delta_i, Some(delta)); self.deltas.insert(*delta_i, Some(delta));
}, },
@ -170,7 +170,7 @@ impl TestBuilder {
.delta() .delta()
.transform(&self.documents[*delta_b_i].delta()) .transform(&self.documents[*delta_b_i].delta())
.unwrap(); .unwrap();
log::trace!("a:{:?},b:{:?}", a_prime, b_prime); tracing::trace!("a:{:?},b:{:?}", a_prime, b_prime);
let data_left = self.documents[*delta_a_i].delta().compose(&b_prime).unwrap(); let data_left = self.documents[*delta_a_i].delta().compose(&b_prime).unwrap();
let data_right = self.documents[*delta_b_i].delta().compose(&a_prime).unwrap(); let data_right = self.documents[*delta_b_i].delta().compose(&a_prime).unwrap();
@ -190,20 +190,20 @@ impl TestBuilder {
TestOp::Invert(delta_a_i, delta_b_i) => { TestOp::Invert(delta_a_i, delta_b_i) => {
let delta_a = &self.documents[*delta_a_i].delta(); let delta_a = &self.documents[*delta_a_i].delta();
let delta_b = &self.documents[*delta_b_i].delta(); let delta_b = &self.documents[*delta_b_i].delta();
log::debug!("Invert: "); tracing::debug!("Invert: ");
log::debug!("a: {}", delta_a.to_json()); tracing::debug!("a: {}", delta_a.to_json());
log::debug!("b: {}", delta_b.to_json()); tracing::debug!("b: {}", delta_b.to_json());
let (_, b_prime) = delta_a.transform(delta_b).unwrap(); let (_, b_prime) = delta_a.transform(delta_b).unwrap();
let undo = b_prime.invert(&delta_a); let undo = b_prime.invert(&delta_a);
let new_delta = delta_a.compose(&b_prime).unwrap(); let new_delta = delta_a.compose(&b_prime).unwrap();
log::debug!("new delta: {}", new_delta.to_json()); tracing::debug!("new delta: {}", new_delta.to_json());
log::debug!("undo delta: {}", undo.to_json()); tracing::debug!("undo delta: {}", undo.to_json());
let new_delta_after_undo = new_delta.compose(&undo).unwrap(); let new_delta_after_undo = new_delta.compose(&undo).unwrap();
log::debug!("inverted delta a: {}", new_delta_after_undo.to_string()); tracing::debug!("inverted delta a: {}", new_delta_after_undo.to_string());
assert_eq!(delta_a, &&new_delta_after_undo); assert_eq!(delta_a, &&new_delta_after_undo);

9
rust-lib/flowy-log/src/lib.rs
View File

@ -10,12 +10,7 @@ use std::sync::RwLock;
use tracing_appender::{non_blocking::WorkerGuard, rolling::RollingFileAppender}; use tracing_appender::{non_blocking::WorkerGuard, rolling::RollingFileAppender};
use tracing_bunyan_formatter::JsonStorageLayer; use tracing_bunyan_formatter::JsonStorageLayer;
use tracing_log::LogTracer; use tracing_log::LogTracer;
use tracing_subscriber::{ use tracing_subscriber::{field::MakeExt, fmt::format, layer::SubscriberExt, EnvFilter};
field::MakeExt,
fmt::{format, format::FmtSpan},
layer::SubscriberExt,
EnvFilter,
};
lazy_static! { lazy_static! {
static ref LOG_GUARD: RwLock<Option<WorkerGuard>> = RwLock::new(None); static ref LOG_GUARD: RwLock<Option<WorkerGuard>> = RwLock::new(None);
@ -150,6 +145,6 @@ mod tests {
#[tracing::instrument(name = "say")] #[tracing::instrument(name = "say")]
fn say(s: &str) { fn say(s: &str) {
log::info!("{}", s); tracing::info!("{}", s);
} }
} }

1
rust-lib/flowy-net/Cargo.toml
View File

@ -15,6 +15,7 @@ serde_repr = "0.1"
pin-project = "1.0.0" pin-project = "1.0.0"
futures-core = { version = "0.3", default-features = false } futures-core = { version = "0.3", default-features = false }
log = "0.4" log = "0.4"
tracing = { version = "0.1", features = ["log"] }
bytes = { version = "1.0", features = ["serde"]} bytes = { version = "1.0", features = ["serde"]}
lazy_static = "1.4.0" lazy_static = "1.4.0"
tokio = { version = "1", features = ["full"] } tokio = { version = "1", features = ["full"] }

2
rust-lib/flowy-net/src/request/request.rs
View File

@ -148,7 +148,7 @@ impl HttpRequestBuilder {
}); });
let response = rx.await??; let response = rx.await??;
log::trace!("Http Response: {:?}", response); tracing::trace!("Http Response: {:?}", response);
let flowy_response = flowy_response_from(response).await?; let flowy_response = flowy_response_from(response).await?;
let token = self.token(); let token = self.token();
self.middleware.iter().for_each(|middleware| { self.middleware.iter().for_each(|middleware| {

1
rust-lib/flowy-ot/Cargo.toml
View File

@ -11,6 +11,7 @@ serde = { version = "1.0", features = ["derive"] }
serde_json = {version = "1.0"} serde_json = {version = "1.0"}
derive_more = {version = "0.99", features = ["display"]} derive_more = {version = "0.99", features = ["display"]}
log = "0.4" log = "0.4"
tracing = { version = "0.1", features = ["log"] }
lazy_static = "1.4.0" lazy_static = "1.4.0"
strum = "0.21" strum = "0.21"
strum_macros = "0.21" strum_macros = "0.21"

1
rust-lib/flowy-ot/src/core/attributes/attribute.rs
View File

@ -3,7 +3,6 @@
use crate::{block_attribute, core::Attributes, ignore_attribute, inline_attribute, list_attribute}; use crate::{block_attribute, core::Attributes, ignore_attribute, inline_attribute, list_attribute};
use lazy_static::lazy_static; use lazy_static::lazy_static;
use serde_json::Error;
use std::{collections::HashSet, fmt, fmt::Formatter, iter::FromIterator}; use std::{collections::HashSet, fmt, fmt::Formatter, iter::FromIterator};
use strum_macros::Display; use strum_macros::Display;

1
rust-lib/flowy-ot/src/core/attributes/attributes_serde.rs
View File

@ -4,7 +4,6 @@ use crate::core::{Attribute, AttributeKey, Attributes};
use serde::{ use serde::{
de, de,
de::{MapAccess, Visitor}, de::{MapAccess, Visitor},
ser,
ser::SerializeMap, ser::SerializeMap,
Deserialize, Deserialize,
Deserializer, Deserializer,

22
rust-lib/flowy-ot/src/core/delta/delta.rs
View File

@ -78,8 +78,8 @@ impl Delta {
pub fn from_json(json: &str) -> Result<Self, OTError> { pub fn from_json(json: &str) -> Result<Self, OTError> {
let delta: Delta = serde_json::from_str(json).map_err(|e| { let delta: Delta = serde_json::from_str(json).map_err(|e| {
log::trace!("Deserialize failed: {:?}", e); tracing::trace!("Deserialize failed: {:?}", e);
log::trace!("{:?}", json); tracing::trace!("{:?}", json);
e e
})?; })?;
Ok(delta) Ok(delta)
@ -426,9 +426,9 @@ impl OperationTransformable for Delta {
if other.is_empty() { if other.is_empty() {
return inverted; return inverted;
} }
log::trace!("🌜Calculate invert delta"); tracing::trace!("🌜Calculate invert delta");
log::trace!("current: {}", self); tracing::trace!("current: {}", self);
log::trace!("other: {}", other); tracing::trace!("other: {}", other);
let mut index = 0; let mut index = 0;
for op in &self.ops { for op in &self.ops {
let len: usize = op.len() as usize; let len: usize = op.len() as usize;
@ -441,34 +441,34 @@ impl OperationTransformable for Delta {
match op.has_attribute() { match op.has_attribute() {
true => invert_from_other(&mut inverted, other, op, index, index + len), true => invert_from_other(&mut inverted, other, op, index, index + len),
false => { false => {
log::trace!("invert retain: {} by retain {} {}", op, len, op.get_attributes()); tracing::trace!("invert retain: {} by retain {} {}", op, len, op.get_attributes());
inverted.retain(len as usize, op.get_attributes()) inverted.retain(len as usize, op.get_attributes())
}, },
} }
index += len; index += len;
}, },
Operation::Insert(_) => { Operation::Insert(_) => {
log::trace!("invert insert: {} by delete {}", op, len); tracing::trace!("invert insert: {} by delete {}", op, len);
inverted.delete(len as usize); inverted.delete(len as usize);
}, },
} }
} }
log::trace!("🌛invert result: {}", inverted); tracing::trace!("🌛invert result: {}", inverted);
inverted inverted
} }
} }
fn invert_from_other(base: &mut Delta, other: &Delta, operation: &Operation, start: usize, end: usize) { fn invert_from_other(base: &mut Delta, other: &Delta, operation: &Operation, start: usize, end: usize) {
log::trace!("invert op: {} [{}:{}]", operation, start, end); tracing::trace!("invert op: {} [{}:{}]", operation, start, end);
let other_ops = DeltaIter::from_interval(other, Interval::new(start, end)).ops(); let other_ops = DeltaIter::from_interval(other, Interval::new(start, end)).ops();
other_ops.into_iter().for_each(|other_op| match operation { other_ops.into_iter().for_each(|other_op| match operation {
Operation::Delete(n) => { Operation::Delete(n) => {
log::trace!("invert delete: {} by add {}", n, other_op); tracing::trace!("invert delete: {} by add {}", n, other_op);
base.add(other_op); base.add(other_op);
}, },
Operation::Retain(_retain) => { Operation::Retain(_retain) => {
log::trace!( tracing::trace!(
"invert attributes: {:?}, {:?}", "invert attributes: {:?}, {:?}",
operation.get_attributes(), operation.get_attributes(),
other_op.get_attributes() other_op.get_attributes()

4
rust-lib/flowy-ot/src/core/delta/iterator.rs
View File

@ -154,13 +154,13 @@ impl<'a> Iterator for AttributesIter<'a> {
match next_op.unwrap() { match next_op.unwrap() {
Operation::Delete(_n) => {}, Operation::Delete(_n) => {},
Operation::Retain(retain) => { Operation::Retain(retain) => {
log::trace!("extend retain attributes with {} ", &retain.attributes); tracing::trace!("extend retain attributes with {} ", &retain.attributes);
attributes.extend(retain.attributes.clone()); attributes.extend(retain.attributes.clone());
length = retain.n; length = retain.n;
}, },
Operation::Insert(insert) => { Operation::Insert(insert) => {
log::trace!("extend insert attributes with {} ", &insert.attributes); tracing::trace!("extend insert attributes with {} ", &insert.attributes);
attributes.extend(insert.attributes.clone()); attributes.extend(insert.attributes.clone());
length = insert.num_chars(); length = insert.num_chars();
}, },

2
rust-lib/flowy-ot/src/core/operation/operation.rs
View File

@ -173,7 +173,7 @@ impl fmt::Display for Retain {
impl Retain { impl Retain {
pub fn merge_or_new(&mut self, n: usize, attributes: Attributes) -> Option<Operation> { pub fn merge_or_new(&mut self, n: usize, attributes: Attributes) -> Option<Operation> {
log::trace!( tracing::trace!(
"merge_retain_or_new_op: len: {:?}, l: {} - r: {}", "merge_retain_or_new_op: len: {:?}, l: {} - r: {}",
n, n,
self.attributes, self.attributes,

2
rust-lib/flowy-user/src/services/user/database.rs
View File

@ -25,7 +25,7 @@ impl UserDB {
return Err(UserError::internal().context("user id is empty")); return Err(UserError::internal().context("user id is empty"));
} }
log::info!("open user db {}", user_id); tracing::info!("open user db {}", user_id);
let dir = format!("{}/{}", self.db_dir, user_id); let dir = format!("{}/{}", self.db_dir, user_id);
let db = flowy_database::init(&dir).map_err(|e| { let db = flowy_database::init(&dir).map_err(|e| {
log::error!("init user db failed, {:?}, user_id: {}", e, user_id); log::error!("init user db failed, {:?}, user_id: {}", e, user_id);

4
rust-lib/flowy-user/src/services/user/user_session.rs
View File

@ -246,7 +246,7 @@ impl UserSession {
} }
fn set_session(&self, session: Option<Session>) -> Result<(), UserError> { fn set_session(&self, session: Option<Session>) -> Result<(), UserError> {
log::debug!("Set user session: {:?}", session); tracing::debug!("Set user session: {:?}", session);
match &session { match &session {
None => KV::remove(SESSION_CACHE_KEY).map_err(|e| UserError::new(ErrorCode::InternalError, &e))?, None => KV::remove(SESSION_CACHE_KEY).map_err(|e| UserError::new(ErrorCode::InternalError, &e))?,
Some(session) => KV::set_str(SESSION_CACHE_KEY, session.clone().into()), Some(session) => KV::set_str(SESSION_CACHE_KEY, session.clone().into()),
@ -297,7 +297,7 @@ impl UserSession {
loop { loop {
match notify.recv().await { match notify.recv().await {
Ok(state) => { Ok(state) => {
log::info!("Websocket state changed: {}", state); tracing::info!("Websocket state changed: {}", state);
match state { match state {
WsState::Init => {}, WsState::Init => {},
WsState::Connected(_) => {}, WsState::Connected(_) => {},

2
rust-lib/flowy-workspace/src/services/trash_can.rs
View File

@ -223,7 +223,7 @@ impl TrashCan {
spawn(async move { spawn(async move {
match server.read_trash(&token).await { match server.read_trash(&token).await {
Ok(repeated_trash) => { Ok(repeated_trash) => {
log::debug!("Remote trash count: {}", repeated_trash.items.len()); tracing::debug!("Remote trash count: {}", repeated_trash.items.len());
match pool.get() { match pool.get() {
Ok(conn) => { Ok(conn) => {
let result = conn.immediate_transaction::<_, WorkspaceError, _>(|| { let result = conn.immediate_transaction::<_, WorkspaceError, _>(|| {

6
rust-lib/flowy-workspace/src/services/workspace_controller.rs
View File

@ -263,14 +263,14 @@ impl WorkspaceController {
// Opti: handle the error and retry? // Opti: handle the error and retry?
let workspaces = server.read_workspace(&token, params).await?; let workspaces = server.read_workspace(&token, params).await?;
let _ = (&*conn).immediate_transaction::<_, WorkspaceError, _>(|| { let _ = (&*conn).immediate_transaction::<_, WorkspaceError, _>(|| {
log::debug!("Save {} workspace", workspaces.len()); tracing::debug!("Save {} workspace", workspaces.len());
for workspace in &workspaces.items { for workspace in &workspaces.items {
let mut m_workspace = workspace.clone(); let mut m_workspace = workspace.clone();
let apps = m_workspace.apps.into_inner(); let apps = m_workspace.apps.into_inner();
let workspace_table = WorkspaceTable::new(m_workspace, &user_id); let workspace_table = WorkspaceTable::new(m_workspace, &user_id);
let _ = workspace_sql.create_workspace(workspace_table, &*conn)?; let _ = workspace_sql.create_workspace(workspace_table, &*conn)?;
log::debug!("Save {} apps", apps.len()); tracing::debug!("Save {} apps", apps.len());
for mut app in apps { for mut app in apps {
let views = app.belongings.into_inner(); let views = app.belongings.into_inner();
match app_ctrl.save_app(app, &*conn) { match app_ctrl.save_app(app, &*conn) {
@ -278,7 +278,7 @@ impl WorkspaceController {
Err(e) => log::error!("create app failed: {:?}", e), Err(e) => log::error!("create app failed: {:?}", e),
} }
log::debug!("Save {} views", views.len()); tracing::debug!("Save {} views", views.len());
for view in views { for view in views {
match view_ctrl.save_view(view, &*conn) { match view_ctrl.save_view(view, &*conn) {
Ok(_) => {}, Ok(_) => {},

1
rust-lib/flowy-ws/Cargo.toml
View File

@ -21,6 +21,7 @@ futures-core = { version = "0.3", default-features = false }
paste = "1" paste = "1"
url = "2.2.2" url = "2.2.2"
log = "0.4" log = "0.4"
tracing = { version = "0.1", features = ["log"] }
protobuf = {version = "2.18.0"} protobuf = {version = "2.18.0"}
strum = "0.21" strum = "0.21"
strum_macros = "0.21" strum_macros = "0.21"

4
rust-lib/flowy-ws/src/connect.rs
View File

@ -60,7 +60,7 @@ impl Future for WsConnectionFuture {
loop { loop {
return match ready!(self.as_mut().project().fut.poll(cx)) { return match ready!(self.as_mut().project().fut.poll(cx)) {
Ok((stream, _)) => { Ok((stream, _)) => {
log::debug!("🐴 ws connect success"); tracing::debug!("🐴 ws connect success");
let (msg_tx, ws_rx) = ( let (msg_tx, ws_rx) = (
self.msg_tx.take().expect("WsConnection should be call once "), self.msg_tx.take().expect("WsConnection should be call once "),
self.ws_rx.take().expect("WsConnection should be call once "), self.ws_rx.take().expect("WsConnection should be call once "),
@ -68,7 +68,7 @@ impl Future for WsConnectionFuture {
Poll::Ready(Ok(WsStream::new(msg_tx, ws_rx, stream))) Poll::Ready(Ok(WsStream::new(msg_tx, ws_rx, stream)))
}, },
Err(error) => { Err(error) => {
log::debug!("🐴 ws connect failed: {:?}", error); tracing::debug!("🐴 ws connect failed: {:?}", error);
Poll::Ready(Err(error.into())) Poll::Ready(Err(error.into()))
}, },
}; };

2
rust-lib/flowy-ws/src/ws.rs
View File

@ -171,7 +171,7 @@ async fn spawn_stream_and_handlers(
} }
} }
}, },
result = handlers => log::debug!("handlers completed {:?}", result), result = handlers => tracing::debug!("handlers completed {:?}", result),
}; };
} }

2
scripts/flowy-tool/src/util/file.rs
View File

@ -48,7 +48,7 @@ pub fn save_content_to_file_with_diff_prompt(content: &str, output_file: &str, _
// if Confirm::new().with_prompt("Override?").interact().unwrap() { // if Confirm::new().with_prompt("Override?").interact().unwrap() {
// write_to_file() // write_to_file()
// } else { // } else {
// log::info!("never mind then :("); // tracing::info!("never mind then :(");
// } // }
// } // }
} }