node: Update logging config — heartwood

Promote message logging to debug level, and change default level to info.

This is because trace level often covers details at a different level of detail than for eg. messages sent and received. This means we don’t have to use trace level just to see the gossip.

 use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
 use std::{fs, io, path::Path, process, thread, time};
 use anyhow::anyhow;
 use localtime::LocalTime;
 use radicle::node;

             .stdin(process::Stdio::null())
             .stdout(process::Stdio::from(log.try_clone()?))
             .stderr(process::Stdio::from(log))
             .spawn()?;
             .spawn()
             .map_err(|e| anyhow!("failed to start node process {cmd:?}: {e}"))?;
         let pid = term::format::parens(term::format::dim(child.id()));
         if verbose {

         let mut child = process::Command::new(cmd)
             .args(options)
             .envs(envs)
             .spawn()?;
             .spawn()
             .map_err(|e| anyhow!("failed to start node process {cmd:?}: {e}"))?;
         child.wait()?;
     }

     --config             <path>         Config file to use (default ~/.radicle/config.json)
     --force                             Force start even if an existing control socket is found
     --listen             <address>      Address to listen on
     --log                <level>        Set log level (default: info)
     --version                           Print program version
     --help                              Print help
 "#;

 struct Options {
     config: Option<PathBuf>,
     listen: Vec<net::SocketAddr>,
     log: log::Level,
     force: bool,
 }

         let mut listen = Vec::new();
         let mut config = None;
         let mut force = false;
         let mut log = log::Level::Info;
         while let Some(arg) = parser.next()? {
             match arg {

                     let addr = parser.value()?.parse()?;
                     listen.push(addr);
                 }
                 Long("log") => {
                     log = parser.value()?.parse()?;
                 }
                 Long("help") | Short('h') => {
                     println!("{HELP_MSG}");
                     process::exit(0);

         Ok(Self {
             force,
             listen,
             log,
             config,
         })
     }
 }
 fn execute() -> anyhow::Result<()> {
     logger::init(log::Level::Debug)?;
     let home = profile::home()?;
     let options = Options::from_env()?;
     logger::init(options.log)?;
     log::info!(target: "node", "Starting node..");
     log::info!(target: "node", "Version {} ({})", env!("CARGO_PKG_VERSION"), env!("GIT_HEAD"));
     log::info!(target: "node", "Unlocking node keystore..");

                 namespaces,
                 clone,
             }) => {
                 debug!(target: "service", "Fetched {rid} from {remote} successfully");
                 info!(target: "service", "Fetched {rid} from {remote} successfully");
                 for update in &updated {
                     debug!(target: "service", "Ref updated: {update} for {rid}");
                     if update.old() != update.new() {
                         debug!(target: "service", "Ref updated: {update} for {rid}");
                     } else {
                         trace!(target: "service", "Ref skipped: {update} for {rid}");
                     }
                 }
                 self.emitter.emit(Event::RefsFetched {
                     remote,

     }
     pub fn listening(&mut self, local_addr: net::SocketAddr) {
         log::info!(target: "node", "Listening on {local_addr}..");
         info!(target: "node", "Listening on {local_addr}..");
         self.listening.push(local_addr);
     }

     pub fn disconnected(&mut self, remote: NodeId, reason: &DisconnectReason) {
         let since = self.local_time();
         debug!(target: "service", "Disconnected from {} ({})", remote, reason);
         info!(target: "service", "Disconnected from {} ({})", remote, reason);
         self.emitter.emit(Event::PeerDisconnected {
             nid: remote,
             reason: reason.to_string(),

         match self.db.gossip_mut().announced(announcer, announcement) {
             Ok(fresh) => {
                 if !fresh {
                     trace!(target: "service", "Ignoring stale announcement from {announcer} (t={})", self.time());
                     debug!(target: "service", "Ignoring stale announcement from {announcer} (t={})", self.time());
                     return Ok(false);
                 }
             }

             trace!(target: "service", "Rate limiting message from {remote} ({})", peer.addr);
             return Ok(());
         }
         message.log(log::Level::Trace, remote, Link::Inbound);
         message.log(log::Level::Debug, remote, Link::Inbound);
         trace!(target: "service", "Received message {:?} from {}", &message, peer.id);