Adding full logging.

.dockerignore

@@ -2,4 +2,5 @@ ui/node_modules
 ui/dist
 server/target
 docker/dev/volumes
+docker/federation-test/volumes
 .git

ansible/templates/docker-compose.yml

@@ -6,6 +6,8 @@ services:
     ports:
       - "127.0.0.1:8536:8536"
     restart: always
+    environment:
+      - RUST_LOG=debug
     volumes:
       - ./lemmy.hjson:/config/config.hjson:ro
     depends_on:

docker/dev/docker-compose.yml

@@ -18,6 +18,8 @@ services:
     ports:
       - "127.0.0.1:8536:8536"
     restart: always
+    environment:
+      - RUST_LOG=debug
     volumes:
       - ../lemmy.hjson:/config/config.hjson:ro
     depends_on: 

docker/prod/docker-compose.yml

@@ -16,6 +16,8 @@ services:
     ports:
       - "127.0.0.1:8536:8536"
     restart: always
+    environment:
+      - RUST_LOG=debug
     volumes:
       - ./lemmy.hjson:/config/config.hjson:ro
     depends_on:

install.sh

@@ -37,7 +37,7 @@ yarn build
 
 # Build and run the backend
 cd ../server
-cargo run
+RUST_LOG=debug cargo run
 
 # For live coding, where both the front and back end, automagically reload on any save, do:
 # cd ui && yarn start

server/src/api/comment.rs

@@ -2,6 +2,7 @@ use super::*;
 use crate::send_email;
 use crate::settings::Settings;
 use diesel::PgConnection;
+use log::error;
 use std::str::FromStr;
 
 #[derive(Serialize, Deserialize)]
@@ -128,7 +129,7 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
           // Let the uniqueness handle this fail
           match UserMention::create(&conn, &user_mention_form) {
             Ok(_mention) => (),
-            Err(_e) => eprintln!("{}", &_e),
+            Err(_e) => error!("{}", &_e),
           };
 
           // Send an email to those users that have notifications on
@@ -145,7 +146,7 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
               );
               match send_email(subject, &mention_email, &mention_user.name, html) {
                 Ok(_o) => _o,
-                Err(e) => eprintln!("{}", e),
+                Err(e) => error!("{}", e),
               };
             }
           }
@@ -174,7 +175,7 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
               );
               match send_email(subject, &comment_reply_email, &parent_user.name, html) {
                 Ok(_o) => _o,
-                Err(e) => eprintln!("{}", e),
+                Err(e) => error!("{}", e),
               };
             }
           }
@@ -199,7 +200,7 @@ impl Perform<CommentResponse> for Oper<CreateComment> {
               );
               match send_email(subject, &post_reply_email, &parent_user.name, html) {
                 Ok(_o) => _o,
-                Err(e) => eprintln!("{}", e),
+                Err(e) => error!("{}", e),
               };
             }
           }
@@ -318,7 +319,7 @@ impl Perform<CommentResponse> for Oper<EditComment> {
           // Let the uniqueness handle this fail
           match UserMention::create(&conn, &user_mention_form) {
             Ok(_mention) => (),
-            Err(_e) => eprintln!("{}", &_e),
+            Err(_e) => error!("{}", &_e),
           }
         }
       }

server/src/api/user.rs

@@ -3,6 +3,7 @@ use crate::settings::Settings;
 use crate::{generate_random_string, send_email};
 use bcrypt::verify;
 use diesel::PgConnection;
+use log::error;
 use std::str::FromStr;
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -1008,7 +1009,7 @@ impl Perform<PrivateMessageResponse> for Oper<CreatePrivateMessage> {
         );
         match send_email(subject, &email, &recipient_user.name, html) {
           Ok(_o) => _o,
-          Err(e) => eprintln!("{}", e),
+          Err(e) => error!("{}", e),
         };
       }
     }

server/src/lib.rs

@@ -39,6 +39,7 @@ use lettre::smtp::extension::ClientId;
 use lettre::smtp::ConnectionReuseParameters;
 use lettre::{ClientSecurity, SmtpClient, Transport};
 use lettre_email::Email;
+use log::error;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
@@ -190,7 +191,7 @@ fn fetch_iframely_and_pictshare_data(
     Some(url) => match fetch_iframely(&url) {
       Ok(res) => (res.title, res.description, res.thumbnail_url, res.html),
       Err(e) => {
-        eprintln!("iframely err: {}", e);
+        error!("iframely err: {}", e);
         (None, None, None, None)
       }
     },
@@ -202,7 +203,7 @@ fn fetch_iframely_and_pictshare_data(
     Some(iframely_thumbnail_url) => match fetch_pictshare(&iframely_thumbnail_url) {
       Ok(res) => Some(res.url),
       Err(e) => {
-        eprintln!("pictshare err: {}", e);
+        error!("pictshare err: {}", e);
         None
       }
     },

server/src/routes/websocket.rs

@@ -3,6 +3,7 @@ use actix::prelude::*;
 use actix_web::web;
 use actix_web::*;
 use actix_web_actors::ws;
+use log::{error, info};
 use std::time::{Duration, Instant};
 
 pub fn config(cfg: &mut web::ServiceConfig) {
@@ -99,7 +100,6 @@ impl Handler<WSMessage> for WSSession {
   type Result = ();
 
   fn handle(&mut self, msg: WSMessage, ctx: &mut Self::Context) {
-    // println!("id: {} msg: {}", self.id, msg.0);
     ctx.text(msg.0);
   }
 }
@@ -107,11 +107,10 @@ impl Handler<WSMessage> for WSSession {
 /// WebSocket message handler
 impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WSSession {
   fn handle(&mut self, result: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
-    // println!("WEBSOCKET MESSAGE: {:?} from id: {}", msg, self.id);
     let message = match result {
       Ok(m) => m,
       Err(e) => {
-        println!("{}", e);
+        error!("{}", e);
         return;
       }
     };
@@ -125,7 +124,7 @@ impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WSSession {
       }
       ws::Message::Text(text) => {
         let m = text.trim().to_owned();
-        println!("WEBSOCKET MESSAGE: {:?} from id: {}", &m, self.id);
+        info!("Message received: {:?} from id: {}", &m, self.id);
 
         self
           .cs_addr
@@ -138,14 +137,14 @@ impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for WSSession {
             match res {
               Ok(res) => ctx.text(res),
               Err(e) => {
-                eprintln!("{}", &e);
+                error!("{}", &e);
               }
             }
             actix::fut::ready(())
           })
           .wait(ctx);
       }
-      ws::Message::Binary(_bin) => println!("Unexpected binary"),
+      ws::Message::Binary(_bin) => info!("Unexpected binary"),
       ws::Message::Close(_) => {
         ctx.stop();
       }
@@ -163,7 +162,7 @@ impl WSSession {
       // check client heartbeats
       if Instant::now().duration_since(act.hb) > CLIENT_TIMEOUT {
         // heartbeat timed out
-        println!("Websocket Client heartbeat failed, disconnecting!");
+        error!("Websocket Client heartbeat failed, disconnecting!");
 
         // notify chat server
         act.cs_addr.do_send(Disconnect {

server/src/websocket/server.rs

@@ -6,7 +6,7 @@ use actix::prelude::*;
 use diesel::r2d2::{ConnectionManager, Pool, PooledConnection};
 use diesel::PgConnection;
 use failure::Error;
-use log::warn;
+use log::{error, info, warn};
 use rand::{rngs::ThreadRng, Rng};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -344,7 +344,7 @@ impl ChatServer {
           }
 
           if rate_limit.allowance < 1.0 {
-            println!(
+            warn!(
               "Rate limited IP: {}, time_passed: {}, allowance: {}",
               &info.ip, time_passed, rate_limit.allowance
             );
@@ -388,7 +388,7 @@ impl Handler<Connect> for ChatServer {
   fn handle(&mut self, msg: Connect, _ctx: &mut Context<Self>) -> Self::Result {
     // register session with random id
     let id = self.rng.gen::<usize>();
-    println!("{} joined", &msg.ip);
+    info!("{} joined", &msg.ip);
 
     self.sessions.insert(
       id,
@@ -451,11 +451,11 @@ impl Handler<StandardMessage> for ChatServer {
   fn handle(&mut self, msg: StandardMessage, _: &mut Context<Self>) -> Self::Result {
     match parse_json_message(self, msg) {
       Ok(m) => {
-        println!("Message Sent: {}", m);
+        info!("Message Sent: {}", m);
         MessageResult(m)
       }
       Err(e) => {
-        warn!("Error during message handling {}", e);
+        error!("Error during message handling {}", e);
         MessageResult(e.to_string())
       }
     }