使用 log 加具体实现库，完成 rust 的日志操作~



# log - 日志门面
`slf4j` 是 Java 的日志门面库，`log` 是 Rust 的日志门面库，由官方积极维护可以放心使用。相应的日志 API 已成为事实上的标准，被其它日志框架所使用，有了日志门面开发者可以很方便切换自己的日志框架。
> A lightweight logging facade.
> 
> The log crate provides a single logging API that abstracts over the actual logging implementation. Libraries can use the logging API provided by this crate, and the consumer of those libraries can choose the logging implementation that is most suitable for its use case.
> 
> If no logging implementation is selected, the facade falls back to a “noop” implementation that ignores all log messages. The overhead in this case is very small - just an integer load, comparison and jump.
> 
> A log request consists of a target, a level, and a body. A target is a string which defaults to the module path of the location of the log request, though that default may be overridden. Logger implementations typically use the target to filter requests based on some user configuration.

## 使用
引入
```toml
[dependencies]
log = "0.4"
```
或
```shell
cargo add log
```
使用
```rust
use log::{info, warn,error,trace};

fn main() {
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}
```
运行上面的示例，实际上看不到任何输出。因为 log 仅仅是日志门面库，它并不具备完整的日志库功能！
因为 log 仅仅是日志门面库，对于库和应用的开发者来说使用方法是有区别的，这也是 log 包这么设计的优势所在。

除了以上常用的，`log` 还提供了 `log!` 和 `log_enabled!` 宏，后者用于确定一条消息在当前模块中，对于给定的日志级别是否能够被记录。
```rust
use log::Level::Debug;
use log::{debug, log_enabled};

// 判断能否记录 Debug 消息
if log_enabled!(Debug) {
    let data = expensive_call();
     // 下面的日志记录较为昂贵，因此我们先在前面判断了是否能够记录，能，才继续这里的逻辑
    debug!("expensive debug data: {} {}", data.x, data.y);
}
if log_enabled!(target: "Global", Debug) {
   let data = expensive_call();
   debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
}
```
而 `log!` 宏就简单的多，它是一个通用的日志记录方式，因此需要我们手动指定日志级别：
```rust
use log::{log, Level};

let data = (42, "Forty-two");
let private_data = "private";

log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
    data.0, data.1, private_data);
```


### 库的开发者
作为库的开发者，你只要在库中使用门面库即可，将具体的日志库交给用户去选择和绑定：
```rust
use log::{info, trace, warn};
pub fn deal_with_something() {
    // 开始处理

    // 记录一些日志
    trace!("a trace log");
    info!("a info long: {}", "abc");
    warn!("a warning log: {}, retrying", err);

    // 结束处理
}
```
### 应用开发者
如果是应用开发者，就需要去选择一个具体的日志库了。

目前已经有了不少日志库实现，官方在 github 上也推荐了一些 ，主要分为以下几类：

- 简单的最小记录器，如 env_logger 等
- 复杂的可配置框架，如 log4rs 等
- 其他设施的适配器，如 syslog、db_logger 等
- 对于 WebAssembly 二进制文件：console_log
- 对于动态库：需要在日志上构造一个 FFI 安全包装器，以便在库中进行初始化。
- 实用程序，如 alterable_logger 等

### 日志库开发者
对于日志库开发者而言，自然要实现自己的 Log 特征:
```rust
use log::{Record, Level, Metadata};
struct SimpleLogger;
impl log::Log for SimpleLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Info
    }
    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            println!("{} - {}", record.level(), record.args());
        }
    }
    fn flush(&self) {}
}
```
除此之外，还需要包装下 `set_logger` 和 `set_max_level`：
```rust
use log::{SetLoggerError, LevelFilter};
static LOGGER: SimpleLogger = SimpleLogger;
pub fn init() -> Result<(), SetLoggerError> {
    log::set_logger(&LOGGER)
        .map(|()| log::set_max_level(LevelFilter::Info))
}
```
然后在 `main` 函数里设置全局记录器：
```rust
use log::{info, warn,error,trace};

fn main() {
    //设置日志
    init();
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}
```
运行后终端输出如下，因为设置日志等级为Info，所以没有输出Trace等级日志：
```log
INFO - This is an info message
WARN - This is a warning message
ERROR - This is an error message
```

# log4rs
[`log4rs`](https://github.com/estk/log4rs/tree/main) 是一个高度可配置的日志框架，以 Java 的 `Logback` 和 `log4j` 库为模型。

## 使用
### 添加依赖
```shell
cargo add log4rs
```
### 添加配置文件
在项目根目录下，创建一个 `log4rs.yaml` 配置文件，并添加以下内容：
```yaml
refresh_rate: 30 seconds

appenders:
  stdout:
    kind: console
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
  
  rolling_file:
    kind: rolling_file
    path: logs/test.log
    append: true 
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
    policy:
      kind: compound
      trigger:
        kind: size
        limit: 10 mb
      roller:        
        kind: fixed_window
        pattern: logs/test.{}.log
        base: 1
        count: 5
        
root:
  level: info 
  appenders:
    - stdout
    - rolling_file
```
上面配置文件设定日志输出到控制台、文件，文件按10 mb大小滚动，只保留最近五个文件。各个配置字段的具体含义可以参考配置：
- refresh_rate：用于确定 log4rs 扫描配置文件以查找更改的频率，如果发现更改，记录器将自动重新配置
- appender： 负责将日志收集到文件、控制台或系统日志, 可配置多个
- stdout、rolling_file：追加器的唯一标识字符串，自己随便定义，它的 kind 字段只支持console、file、rolling_file 三种实现
- encoder： 负责将 log 信息转换为合适的格式, 如固定格式的平文本或json
- pattern：编码模板，格式可配置，具体格式详见pattern
- policy：策略字段，策略必须具有 kind 字段，默认（且仅受支持）策略为 kind: compound
- trigger：触发器字段用于指示何时滚动日志文件，支持 size 和 time 两种类型，这里使用的是按大小

### 使用
```rust
use log::*;
use log4rs;

fn main() {
    log4rs::init_file("log4rs.yaml", Default::default()).unwrap();

    for i in 1..=1000 {
        info!("This is loop iteration {}", i);
    }
}
```
运行结果
```log
2024-04-01 15:43:28.596832500 [INFO] hello_world - This is loop iteration 1
```

# 参考
> [Rust 实现日志记录功能](https://www.cnblogs.com/timefiles/p/18108881)

Rust 日志

canvas 实现粒子效果案例~



```html
<html>
    <head> </head>
    <body>
        <canvas id="canvas"></canvas>
        <script>
            class Vector2 {
                constructor(x, y) {
                    this.x = x;
                    this.y = y;
                }
                set(x, y) {
                    this.x = x;
                    this.y = y;
                    return this;
                }
                clone() {
                    return new Vector2(this.x, this.y);
                }
                add(v) {
                    this.x += v.x;
                    this.y += v.y;
                    return this;
                }
                sub(v) {
                    this.x -= v.x;
                    this.y -= v.y;
                    return this;
                }
                mult(v) {
                    this.x *= v.x;
                    this.y *= v.y;
                    return this;
                }
                magnitude() {
                    return Math.sqrt(this.x * this.x + this.y * this.y);
                }
                setFromScalarAngle(scalar, angle) {
                    this.x = Math.cos(angle) * scalar;
                    this.y = Math.sin(angle) * scalar;
                }
            }

            class Particle {
                constructor(canvas, x, y, scalar, direction, radius, color) {
                    this.canvas = canvas;
                    this.position = new Vector2(x, y);
                    this.velocity = new Vector2();
                    this.velocity.setFromScalarAngle(scalar, direction);
                    this.radius = radius;
                    this.color = color;
                    this.range = 100;
                }
                update() {
                    this.position.add(this.velocity);

                    if (this.position.x - this.range > this.canvas.width) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.x + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y - this.range > this.canvas.height) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                }
            }

            window.onload = function () {
                var canvas = document.getElementById("canvas"),
                    ctx = canvas.getContext("2d"),
                    width = (canvas.width = window.innerWidth),
                    height = (canvas.height = window.innerHeight),
                    particles = [],
                    particleNum = 100,
                    colors = [
                        "#0952BD",
                        "#A5BFF0",
                        "#118CD6",
                        "#1AAEE8",
                        "#F2E8C9",
                    ];

                window.onresize = () => {
                    width = canvas.width = window.innerWidth;
                    height = canvas.height = window.innerHeight;
                };

                function randomIntFromRange(min, max) {
                    return Math.floor(Math.random() * (max - min + 1) + min);
                }
                function randomColor(colors) {
                    return colors[Math.floor(Math.random() * colors.length)];
                }

                for (let i = 0; i < particleNum; i++) {
                    particles.push(
                        new Particle(
                            canvas,
                            canvas.width / 2,
                            canvas.height / 2,
                            Math.random() * 8 + 2,
                            Math.random() * Math.PI * 2,
                            randomIntFromRange(5, 7),
                            randomColor(colors),
                        ),
                    );
                }

                function draw() {
                    for (let i = 0; i < particleNum; i++) {
                        var p = particles[i];
                        p.update();
                        ctx.save();
                        ctx.beginPath();
                        ctx.arc(
                            p.position.x,
                            p.position.y,
                            p.radius,
                            0,
                            Math.PI * 2,
                        );
                        ctx.shadowColor = p.color;
                        ctx.shadowBlur = 5;
                        ctx.shadowOffsetX = 0;
                        ctx.shadowOffsetY = 0;
                        ctx.globalAlpha = "1";
                        ctx.fillStyle = p.color;
                        ctx.fill();
                        ctx.restore();
                    }
                }

                render();

                function render() {
                    ctx.fillStyle = "hsla(260,40%,5%,.2)";
                    ctx.fillRect(0, 0, width, height);
                    draw();
                    requestAnimationFrame(render);
                }
            };
        </script>
    </body>
</html>
```

web 粒子效果

使用 [豆包网页版](https://www.doubao.com/chat/) 的接口实现**文字转语音**
![image.png](/static/img/32869c52e5804dcdb5f1ebd9740e27fe.image.png)



F12 查看逻辑

![image.png](/static/img/34e3b5733e759dead56fe435bac46fa4.image.png)

通过 webservice，先发送请求，内容为需要转为语音的文字
```json
{"event":"text","text":"以下分别从给朋友、家人、同事三个角度，为你创作新春祝福：\n\n### 给朋友\n宝子，龙年新春到啦！愿你在这新的一年，像龙一样威风凛凛，活力满满！所有的倒霉事都被龙尾巴一扫而光，好事则如烟花般噼里啪啦接踵而至。愿你去想去的地方，见想见的人，做想做的事，每一天都能笑出鹅叫，快乐到飞起！新的一年，咱们继续一起疯，一起闹，一起把生活折腾得热气腾腾！ \n\n### 给家人\n亲爱的家人们，龙年钟声敲响，新春佳节已至。在这祥龙贺岁的美好时刻，愿咱们一家人如同龙行四海般，运势亨通，生活顺意。希望长辈们身体硬朗，吃嘛嘛香，尽享天伦之乐；孩子们活泼聪慧，学业如芝麻开花节节高；而我们这些中坚力量，事业腾飞，工作轻松又多金。一家人整整齐齐，和和美美，一起迎接龙年里每一个灿烂的日子，让幸福的笑声永远在咱们家中回荡。 \n\n### 给同事\n各位同事，祥龙贺岁，福满人间！值此新春佳节，愿我们在龙年里，如同蛟龙得水，在工作的海洋中畅快遨游，业绩如飞龙在天，一飞冲天。新的一年，咱们携手共进，以龙的精神，攻坚克难，让项目顺利推进，让团队蒸蒸日上。也希望大家在忙碌工作之余，能尽情享受生活的美好，阖家欢乐，幸福安康，共同开启龙年的辉煌篇章！ "}	
```
webservice 就会返回 mp3 的二进制文件，拼接在一起即完整的 mp3.

完整代码，仅供参考
```go
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/gorilla/websocket"
)

// 文字转语音
func main() {
	// WebSocket 服务的地址 (wss:// 或 ws://)
	url := "wss://ws-samantha.doubao.com/samantha/audio/tts?speaker=zh_female_taozi_conversation_v4_wvae_bigtts&format=aac&speech_rate=0&pitch=0&version_code=20800&language=zh&device_platform=web&aid=497858&real_aid=497858&pc_version=1.51.82&pkg_type=release_version&device_id=7464034169136465444&web_id=7464034176154175012&tea_uuid=7464034176154175012&use-olympus-account=1&region=CN&sys_region=CN&samantha_web=1"
	// 自定义请求头
	headers := http.Header{}
        // TODO: 放入 cookie
	headers.Add("cookie", "")

	// 创建 WebSocket 连接
	conn, _, err := websocket.DefaultDialer.Dial(url, headers)
	if err != nil {
		log.Fatalf("连接 WebSocket 失败: %v", err)
	}
	defer conn.Close()

	fmt.Println("已连接到 WebSocket")

	// 向服务端发送消息 (如果需要)
	err = conn.WriteMessage(websocket.TextMessage, []byte(`{"event":"text","text":"以下分别从给朋友、家人、同事三个角度，为你创作新春祝福：\n\n### 给朋友\n宝子，龙年新春到啦！愿你在这新的一年，像龙一样威风凛凛，活力满满！所有的倒霉事都被龙尾巴一扫而光，好事则如烟花般噼里啪啦接踵而至。愿你去想去的地方，见想见的人，做想做的事，每一天都能笑出鹅叫，快乐到飞起！新的一年，咱们继续一起疯，一起闹，一起把生活折腾得热气腾腾！ \n\n### 给家人\n亲爱的家人们，龙年钟声敲响，新春佳节已至。在这祥龙贺岁的美好时刻，愿咱们一家人如同龙行四海般，运势亨通，生活顺意。希望长辈们身体硬朗，吃嘛嘛香，尽享天伦之乐；孩子们活泼聪慧，学业如芝麻开花节节高；而我们这些中坚力量，事业腾飞，工作轻松又多金。一家人整整齐齐，和和美美，一起迎接龙年里每一个灿烂的日子，让幸福的笑声永远在咱们家中回荡。 \n\n### 给同事\n各位同事，祥龙贺岁，福满人间！值此新春佳节，愿我们在龙年里，如同蛟龙得水，在工作的海洋中畅快遨游，业绩如飞龙在天，一飞冲天。新的一年，咱们携手共进，以龙的精神，攻坚克难，让项目顺利推进，让团队蒸蒸日上。也希望大家在忙碌工作之余，能尽情享受生活的美好，阖家欢乐，幸福安康，共同开启龙年的辉煌篇章！ "}	`))
	if err != nil {
		log.Fatalf("发送消息失败: %v", err)
	}

	// 创建文件用于保存接收到的数据
	os.Remove("output.mp3")
	file, err := os.Create("output.mp3")
	if err != nil {
		log.Fatalf("创建文件失败: %v", err)
	}
	file.Close()
	file, err = os.OpenFile("output.mp3", os.O_APPEND|os.O_WRONLY, 0644) // 替换为目标文件名
	if err != nil {
		log.Fatalf("创建文件失败: %v", err)
	}
	defer file.Close()

	// 接收消息
outer:
	for {
		messageType, message, err := conn.ReadMessage()
		if err != nil {
			log.Fatalf("读取消息失败: %v", err)
		}

		// 根据消息类型处理
		switch messageType {
		case websocket.TextMessage:
			fmt.Printf("收到文本消息: %s\n", string(message))
			if string(message) == `{"event":"sentence_end","code":0,"message":""}` {
				break outer
			}
		case websocket.BinaryMessage:
			fmt.Printf("收到二进制消息: %x\n", message)
			_, err = file.Write(message)
			if err != nil {
				log.Fatalf("写入文件失败: %v", err)
			}

		default:
			fmt.Println("收到未知消息类型")
		}
	}
}
```

豆包文字转语音

使用树莓派，建立旁路由，科学上网~

网络拓扑

![image.png](/static/img/6e212e9e119fc51b87f881028a105c91.image.png)



**避坑：[Docker 运行 OpenWrt 容器时在进行包含 “杀死 OpenWrt Docker 容器进程” 的操作的时候确实会出现这个问题。目前还不清楚是哪方面的原因。](https://github.com/SuLingGG/OpenWrt-Docker/issues/8)**

**解决办法：关闭容器后尽快删除容器。**

## OpenWrt 使用
### 安装 OpenWrt
为了方便树莓派用于其他用途，使用 docker 的方式
- 下载[镜像包 openwrt-22.03.5-armvirt-64-default-rootfs.tar.gz](https://archive.openwrt.org/releases/22.03.5/targets/armvirt/64/openwrt-22.03.5-armvirt-64-default-rootfs.tar.gz)，来源：https://archive.openwrt.org/releases/22.03.5/targets/armvirt/64/
- 解压得到 tar 包 `gunzip openwrt-22.03.5-armvirt-64-default-rootfs.tar.gz`
- 导入镜像 `docker import openwrt-22.03.5-armvirt-64-default-rootfs.tar openwrt`
  > **推荐**：或者直接在创建 docker 容器时使用 `docker run --restart always --name openwrt -d --network openwrt --privileged registry.cn-shanghai.aliyuncs.com/suling/openwrt:armv8 /sbin/init`
  > 
  > x86 架构使用 `docker run --restart always --name openwrt -d --network openwrt --privileged registry.cn-shanghai.aliyuncs.com/suling/openwrt:x86_64 /sbin/init`
- 打开网卡混杂模式，使网卡可以接收任何流量，添加到启动文件 `ip link set eth0 promisc on`，执行 `ifconfig eth0` 网卡 flag 信息有 `PROMISC` 表示开启成功
  > `eth0: flags=4419<UP,BROADCAST,RUNNING,PROMISC,MULTICAST>  mtu 1500`
- 创建docker网络，网络驱动程序为macvlan，网络命名为openwrt，子网和网关根据实际情况修改 `docker network create -d macvlan --subnet=192.168.3.0/24 --gateway=192.168.3.1 -o parent=eth0 openwrt`
- 创建 docker 容器 `docker run --name openwrt -d --network openwrt --privileged openwrt /sbin/init`
  > 如果报错 `Error response from daemon: failed to create the macvlan port: operation not supported`，执行 `apt install linux-modules-extra-raspi`，linux-modules-extra-raspi 是树莓派 Ubuntu Arm 的不常用扩展，Ubuntu 最新的包管理中默认不包含扩展；因此需要单独安装，安装后需要重启树莓派
- 修改容器网络配置
  ```shell
  docker exec -it openwrt bash
  vi /etc/config/network

  # 修改 lan 配置
  config interface 'lan'
          option ifname 'eth0'
          option proto 'static'
          option netmask '255.255.255.0'
          option ip6assign '60'
          option ipaddr '192.168.1.99'
          option gateway '192.168.1.1'
          option dns '192.168.1.1'
 
  # 修改完成后重启容器的网络
  /etc/init.d/network restart
  ```
  重启完成后访问 http://192.168.1.99 ，使用账户 root 和密码 password 即可进入管理页面
- OpenWrt 配置
    - 登录后在 网络-接口中修改 LAN 接口，在底层基本设置中选择忽略此接口，使用默认路由器做 DHCP 服务器
    ![image.png](/static/img/d807e4a27bdef4777f72451440341b10.image.png)
     

### OpenWrt 安装 OpenClash 插件
[OpenClash Github](https://github.com/vernesong/OpenClash)

[下载地址](https://github.com/vernesong/OpenClash/releases/tag/v0.46.064)

下载 luci-app-openclash 插件，打开 OpenWrt 管理界面，进入系统列表页找到文件传输，选择上传 luci-app-openclash_0.38.7-beta_all.ipk 插件，并在上传文件列表进行安装，如下图：

![image.png](/static/img/eb562acdcee9c2eb0cab24c1d9eb6aea.image.png)

进入服务-OpenClash，选择配置文件订阅，新增订阅；输入订阅的链接地址，保存并更新即可；这样以 OpenWrt 为网关的设备就可以通过 OpenClash 访问特定的资源了

启动

![image.png](/static/img/b1c3e3a40a272173a0c49cc604e37ff3.image.png)

设置路由器的网关和 dns

![image.png](/static/img/e431a7e0f5044d547310bf030144f952.image.png)

## 参考
- [Clash for OpenWRT（软路由）实现全屋设备科学上网](https://inurl.top/archives/ClashforOpenWRT/)
- [树莓派 4B 容器方式安装 OpenWrt 作为软路由](https://blog.hellowood.dev/posts/%E6%A0%91%E8%8E%93%E6%B4%BE-4b-%E5%AE%B9%E5%99%A8%E6%96%B9%E5%BC%8F%E5%AE%89%E8%A3%85-openwrt-%E4%BD%9C%E4%B8%BA%E8%BD%AF%E8%B7%AF%E7%94%B1/)
- [树莓派中装docker，docker中装openwrt](https://zhuanlan.zhihu.com/p/658788125)
- [最新 OpenClash 使用教程快速入门篇](https://openclash.org/)