feat: v1.0.0

Author: eastspire

Cargo.lock

@@ -1,11 +1,11 @@
 [package]
 name = "instrument-level"
-version = "10.14.11"
+version = "1.0.0"
 readme = "README.md"
 edition = "2024"
 authors = ["root@ltpp.vip"]
 license = "MIT"
-description = """"""
+description = "A Rust procedural macro collection providing convenient tracing instrumentation macros for different log levels (trace, debug, info, warn, error). This crate simplifies the process of adding tracing spans to functions with pre-configured log levels."
 keywords = ["http", "request", "response", "tcp", "cross-platform"]
 repository = "https://github.com/crates-dev/instrument-level.git"
 categories = ["network-programming", "web-programming"]

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 尤雨东
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,63 @@
+<center>
+
+## instrument-level
+
+[![](https://img.shields.io/crates/v/instrument-level.svg)](https://crates.io/crates/instrument-level)
+[![](https://img.shields.io/crates/d/instrument-level.svg)](https://img.shields.io/crates/d/instrument-level.svg)
+[![](https://docs.rs/instrument-level/badge.svg)](https://docs.rs/instrument-level)
+[![](https://github.com/crates-dev/instrument-level/workflows/Rust/badge.svg)](https://github.com/crates-dev/instrument-level/actions?query=workflow:Rust)
+[![](https://img.shields.io/crates/l/instrument-level.svg)](./LICENSE)
+
+</center>
+
+[Official Documentation](https://docs.ltpp.vip/instrument-level/)
+
+[Api Docs](https://docs.rs/instrument-level/latest/instrument_level/)
+
+> A Rust procedural macro collection providing convenient tracing instrumentation macros for different log levels (trace, debug, info, warn, error). This crate simplifies the process of adding tracing spans to functions with pre-configured log levels.
+
+## Installation
+
+To use this crate, you can run cmd:
+
+```shell
+cargo add instrument-level
+```
+
+## Usage
+
+This crate provides five attribute macros for different tracing log levels:
+
+### `#[instrument_trace]` - Trace Level Instrumentation
+
+Use this macro to add trace-level logging instrumentation to functions. This is the most verbose log level and automatically excludes all function arguments from span fields using `skip_all`.
+
+### `#[instrument_debug]` - Debug Level Instrumentation
+
+Use this macro to add debug-level logging instrumentation to functions. Ideal for development and debugging purposes.
+
+### `#[instrument_info]` - Info Level Instrumentation
+
+Use this macro to add info-level logging instrumentation to functions. Suitable for general informational messages.
+
+### `#[instrument_warn]` - Warning Level Instrumentation
+
+Use this macro to add warning-level logging instrumentation to functions. Use for potentially harmful situations.
+
+### `#[instrument_error]` - Error Level Instrumentation
+
+Use this macro to add error-level logging instrumentation to functions. Use for error conditions that don't necessarily stop program execution.
+
+Each macro accepts optional tracing parameters such as `target`, `name`, `skip`, `fields`, etc., which can be used to customize the span behavior according to your needs.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Contact
+
+For any inquiries, please reach out to the author at [root@ltpp.vip](mailto:root@ltpp.vip).

README.md

@@ -1,37 +1,23 @@
 use crate::*;
 
-/// Helper function to parse additional instrument parameters from attributes.
-///
-/// # Arguments
-///
-/// - `attr` - The attribute TokenStream containing additional parameters
-///
-/// # Returns
-///
-/// - `TokenStream2` - The parsed additional parameters as a TokenStream
-fn parse_instrument_params(attr: TokenStream) -> TokenStream2 {
-    if attr.is_empty() {
-        return quote! {};
-    }
-    let tokens: TokenStream2 = attr.into();
-    quote! { #tokens }
-}
-
 /// Macro for adding trace-level instrumentation to functions.
 ///
+/// This macro instruments functions with trace-level logging and automatically includes `skip_all`
+/// to exclude all function arguments from the span fields.
+///
 /// # Arguments
 ///
-/// - `_attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The function to instrument
 ///
 /// # Returns
 ///
-/// - `TokenStream` - The instrumented function with trace-level logging
-pub fn instrument_trace_macro(_attr: TokenStream, item: TokenStream) -> TokenStream {
+/// - `TokenStream` - The instrumented function with trace-level logging and skip_all enabled
+pub(crate) fn instrument_trace_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_fn: ItemFn = parse_macro_input!(item as ItemFn);
-    let params: TokenStream2 = parse_instrument_params(_attr);
+    let params: TokenStream2 = attr.into();
     let expanded: TokenStream2 = quote! {
-        #[::tracing::instrument(level = "trace", #params)]
+        #[::tracing::instrument(level = "trace", skip_all, #params)]
         #input_fn
     };
     TokenStream::from(expanded)
@@ -41,15 +27,15 @@ pub fn instrument_trace_macro(_attr: TokenStream, item: TokenStream) -> TokenStr
 ///
 /// # Arguments
 ///
-/// - `_attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The function to instrument
 ///
 /// # Returns
 ///
 /// - `TokenStream` - The instrumented function with debug-level logging
-pub fn instrument_debug_macro(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub(crate) fn instrument_debug_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_fn: ItemFn = parse_macro_input!(item as ItemFn);
-    let params: TokenStream2 = parse_instrument_params(_attr);
+    let params: TokenStream2 = attr.into();
     let expanded: TokenStream2 = quote! {
         #[::tracing::instrument(level = "debug", #params)]
         #input_fn
@@ -61,15 +47,15 @@ pub fn instrument_debug_macro(_attr: TokenStream, item: TokenStream) -> TokenStr
 ///
 /// # Arguments
 ///
-/// - `_attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The function to instrument
 ///
 /// # Returns
 ///
 /// - `TokenStream` - The instrumented function with info-level logging
-pub fn instrument_info_macro(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub(crate) fn instrument_info_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_fn: ItemFn = parse_macro_input!(item as ItemFn);
-    let params: TokenStream2 = parse_instrument_params(_attr);
+    let params: TokenStream2 = attr.into();
     let expanded: TokenStream2 = quote! {
         #[::tracing::instrument(level = "info", #params)]
         #input_fn
@@ -81,15 +67,15 @@ pub fn instrument_info_macro(_attr: TokenStream, item: TokenStream) -> TokenStre
 ///
 /// # Arguments
 ///
-/// - `_attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The function to instrument
 ///
 /// # Returns
 ///
 /// - `TokenStream` - The instrumented function with warn-level logging
-pub fn instrument_warn_macro(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub(crate) fn instrument_warn_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_fn: ItemFn = parse_macro_input!(item as ItemFn);
-    let params: TokenStream2 = parse_instrument_params(_attr);
+    let params: TokenStream2 = attr.into();
     let expanded: TokenStream2 = quote! {
         #[::tracing::instrument(level = "warn", #params)]
         #input_fn
@@ -101,15 +87,15 @@ pub fn instrument_warn_macro(_attr: TokenStream, item: TokenStream) -> TokenStre
 ///
 /// # Arguments
 ///
-/// - `_attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The function to instrument
 ///
 /// # Returns
 ///
 /// - `TokenStream` - The instrumented function with error-level logging
-pub fn instrument_error_macro(_attr: TokenStream, item: TokenStream) -> TokenStream {
+pub(crate) fn instrument_error_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input_fn: ItemFn = parse_macro_input!(item as ItemFn);
-    let params: TokenStream2 = parse_instrument_params(_attr);
+    let params: TokenStream2 = attr.into();
     let expanded: TokenStream2 = quote! {
         #[::tracing::instrument(level = "error", #params)]
         #input_fn

src/instrument/fn.rs

@@ -1,3 +1,7 @@
+//! A Rust procedural macro collection providing convenient tracing instrumentation macros
+//! for different log levels (trace, debug, info, warn, error). This crate simplifies
+//! the process of adding tracing spans to functions with pre-configured log levels.
+
 mod instrument;
 
 pub(crate) use instrument::*;
@@ -9,12 +13,12 @@ pub(crate) use syn::*;
 
 /// Enables trace-level instrumentation for the decorated function.
 ///
-/// This attribute macro wraps the function with `#[::tracing::instrument(level = "trace")]`,
-/// enabling automatic tracing instrumentation at the trace level.
+/// This attribute macro wraps the function with `#[::tracing::instrument(level = "trace", skip_all)]`,
+/// enabling automatic tracing instrumentation at the trace level with all arguments excluded from span fields.
 ///
 /// # Arguments
 ///
-/// - `attr` - The attribute TokenStream (currently unused).
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The TokenStream representing the function to be instrumented.
 ///
 /// # Returns
@@ -49,7 +53,7 @@ pub fn instrument_trace(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// # Arguments
 ///
-/// - `attr` - The attribute TokenStream (currently unused).
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The TokenStream representing the function to be instrumented.
 ///
 /// # Returns
@@ -84,7 +88,7 @@ pub fn instrument_debug(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// # Arguments
 ///
-/// - `attr` - The attribute TokenStream (currently unused).
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The TokenStream representing the function to be instrumented.
 ///
 /// # Returns
@@ -119,7 +123,7 @@ pub fn instrument_info(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// # Arguments
 ///
-/// - `attr` - The attribute TokenStream (currently unused).
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The TokenStream representing the function to be instrumented.
 ///
 /// # Returns
@@ -154,7 +158,7 @@ pub fn instrument_warn(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// # Arguments
 ///
-/// - `attr` - The attribute TokenStream (currently unused).
+/// - `attr` - Additional tracing instrument parameters (optional): target, name, skip, fields, etc.
 /// - `item` - The TokenStream representing the function to be instrumented.
 ///
 /// # Returns