revert back to tracing

Cargo.toml

@@ -3,20 +3,19 @@ name = "puppet"
 version = "0.3.1"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
+tracing = "0"
+tracing-subscriber = "0"
 clap = { version = "4", features = ["derive"] }
 clap_complete = "4"
 serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
-log = "0"
 tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0", features = ["stream"] }
 bytes = "1"
+futures = "0"
 rand = "0"
 base64 = "0"
 uuid = { version = "1", features = ["v4"] }
 regex = "1"
 glob = "0"
-futures = "0"

src/azure/chatgpt.rs

@@ -11,9 +11,9 @@ use bytes::Bytes;
 use futures::AsyncBufReadExt;
 use futures::StreamExt;
 use futures::TryStreamExt;
-use log::info;
 use reqwest::Response;
 use tokio::fs;
+use tracing::info;
 
 use super::chatgpt_api::ChatCompletionChoice;
 use super::chatgpt_api::ChatResponse;
@@ -134,8 +134,8 @@ impl ChatGPT {
                 for result in results {
                     self.add_message(ChatRequestMessage::new_function_response(result.id, json::to_json(&result.value)?));
                 }
-            } else if let Some(content) = message.content {
-                self.add_message(ChatRequestMessage::new_message(Role::Assistant, content));
+            } else {
+                self.add_message(ChatRequestMessage::new_message(Role::Assistant, message.content.unwrap()));
                 return Ok(());
             }
         }
@@ -168,7 +168,8 @@ impl ChatGPT {
         let response = request.send().await?;
         let status = response.status();
         if status != 200 {
-            info!("body={}", str::from_utf8(&body)?);
+            let body = str::from_utf8(&body)?;
+            info!("body={}", body);
             let response_text = response.text().await?;
             return Err(Exception::ExternalError(format!(
                 "failed to call azure api, status={status}, response={response_text}"
@@ -207,7 +208,6 @@ async fn read_sse_response(http_response: Response) -> Result<ChatResponse, Exce
     while let Some(line) = lines.next().await {
         let line = line?;
 
-        // chatgpt always adds space after data:
         if let Some(data) = line.strip_prefix("data: ") {
             if data == "[DONE]" {
                 break;

src/command/complete.rs

@@ -7,12 +7,12 @@ use clap::Args;
 use glob::glob;
 use glob::GlobError;
 use glob::PatternError;
-use log::info;
 use regex::Regex;
 use tokio::fs;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::AsyncWriteExt;
 use tokio::io::BufReader;
+use tracing::info;
 
 use crate::llm;
 use crate::llm::ChatOption;

src/command/speak.rs

@@ -3,11 +3,11 @@ use std::path::PathBuf;
 
 use clap::arg;
 use clap::Args;
-use log::info;
 use tokio::fs;
 use tokio::io::stdin;
 use tokio::io::AsyncReadExt;
 use tokio::process::Command;
+use tracing::info;
 use uuid::Uuid;
 
 use crate::tts;

src/gcloud/gemini.rs

@@ -11,16 +11,17 @@ use bytes::Bytes;
 use futures::AsyncBufReadExt;
 use futures::StreamExt;
 use futures::TryStreamExt;
-use log::info;
 use reqwest::Response;
 use tokio::fs;
+use tracing::info;
 
 use super::gemini_api::Content;
 use super::gemini_api::GenerateContentResponse;
 use super::gemini_api::GenerationConfig;
 use super::gemini_api::InlineData;
 use super::gemini_api::StreamGenerateContent;
 use super::gemini_api::Tool;
+use super::token;
 use crate::gcloud::gemini_api::Candidate;
 use crate::gcloud::gemini_api::GenerateContentStreamResponse;
 use crate::gcloud::gemini_api::Role;
@@ -142,7 +143,7 @@ impl Gemini {
         let body = Bytes::from(body);
         let response = http_client::http_client()
             .post(&self.url)
-            // .bearer_auth(token())
+            .bearer_auth(token())
             .header("Content-Type", "application/json")
             .header("Accept", "application/json")
             .body(body.clone())
@@ -151,7 +152,8 @@ impl Gemini {
 
         let status = response.status();
         if status != 200 {
-            info!("body={}", str::from_utf8(&body)?);
+            let body = str::from_utf8(&body)?;
+            info!("body={}", body);
             let response_text = response.text().await?;
             return Err(Exception::ExternalError(format!(
                 "failed to call gcloud api, status={status}, response={response_text}"
@@ -183,7 +185,7 @@ async fn read_sse_response(http_response: Response) -> Result<GenerateContentRes
     let mut lines = reader.lines();
     while let Some(line) = lines.next().await {
         let line = line?;
-        if let Some(data) = line.strip_prefix("data:") {
+        if let Some(data) = line.strip_prefix("data: ") {
             let stream_response: GenerateContentStreamResponse = json::from_json(data)?;
             if let Some(value) = stream_response.usage_metadata {
                 response.usage_metadata = value;

src/gcloud/tts.rs

@@ -3,9 +3,9 @@ use std::borrow::Cow;
 use base64::prelude::BASE64_STANDARD;
 use base64::DecodeError;
 use base64::Engine;
-use log::info;
 use serde::Deserialize;
 use serde::Serialize;
+use tracing::info;
 
 use super::token;
 use crate::util::exception::Exception;

src/llm.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
-use log::info;
 use tokio::fs;
+use tracing::info;
 
 use crate::azure::chatgpt::ChatGPT;
 use crate::gcloud::gemini::Gemini;

src/llm/config.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 
-use log::info;
 use rand::Rng;
 use serde::Deserialize;
 use serde_json::json;
+use tracing::info;
 
 use super::function::FunctionImplementations;
 use crate::azure::chatgpt::ChatGPT;

src/llm/function.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use log::info;
 use serde::Serialize;
 use tokio::task::JoinSet;
+use tracing::info;
 
 use crate::util::exception::Exception;
 

src/main.rs

@@ -37,6 +37,7 @@ pub enum Command {
 
 #[tokio::main]
 async fn main() -> Result<(), Exception> {
+    tracing_subscriber::fmt().with_thread_ids(true).init();
     let cli = Cli::parse();
     match cli.command {
         Command::Chat(command) => command.execute().await,

src/tts.rs

@@ -1,9 +1,9 @@
 use std::collections::HashMap;
 use std::path::Path;
 
-use log::info;
 use serde::Deserialize;
 use tokio::fs;
+use tracing::info;
 
 use crate::azure::tts::AzureTTS;
 use crate::gcloud::tts::GCloudTTS;