You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by wu...@apache.org on 2022/07/26 15:42:01 UTC

[skywalking-rust] branch master updated: Improve LogReporter and fix tests. (#36)

This is an automated email from the ASF dual-hosted git repository.

wusheng pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/skywalking-rust.git


The following commit(s) were added to refs/heads/master by this push:
     new 6232828  Improve LogReporter and fix tests. (#36)
6232828 is described below

commit 6232828d1eeb4b0eceae0847f1d139e29ff09932
Author: jmjoy <91...@qq.com>
AuthorDate: Tue Jul 26 23:41:56 2022 +0800

    Improve LogReporter and fix tests. (#36)
---
 .github/workflows/ci.yaml       | 55 +++++++++++++++++++++++++++++++++++++----
 Cargo.toml                      |  2 +-
 README.md                       | 11 +++++----
 e2e/src/main.rs                 |  6 ++---
 examples/simple_trace_report.rs | 10 ++++----
 src/context/tracer.rs           | 26 +++++++++++++++----
 src/reporter/grpc.rs            |  4 +--
 src/reporter/log.rs             | 50 ++++++++++++++++++++++++++++++++++---
 src/reporter/mod.rs             |  3 ++-
 tests/propagation.rs            |  2 +-
 tests/trace_context.rs          | 53 ++++++++++++++++++++-------------------
 11 files changed, 165 insertions(+), 57 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ecdc8cd..6bac88c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -32,6 +32,18 @@ env:
 
 jobs:
   CI:
+    needs:
+    - license-check
+    - fmt
+    - check-and-test
+    - doc
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+
+  license-check:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -41,17 +53,50 @@ jobs:
         uses: apache/skywalking-eyes/header/@501a28d2fb4a9b962661987e50cf0219631b32ff
         with:
           config: .github/licenserc.yaml
-      - name: Check dependencies License
+      - name: Check Dependencies License
         uses: apache/skywalking-eyes/dependency/@501a28d2fb4a9b962661987e50cf0219631b32ff
         with:
           config: .github/licenserc.yaml
+
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
       - name: Install Rust toolchain
-        run: rustup toolchain install stable --component clippy --component rustfmt
+        run: rustup toolchain install stable --component rustfmt
       - name: Run format
         run: cargo fmt --all -- --check
+
+  check-and-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        features:
+          - ""
+          - "--all-features"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - name: Install Rust toolchain
+        run: rustup toolchain install stable --component clippy
+      - name: Run check
+        run: cargo check --workspace --release ${{ matrix.features }}
       - name: Run clippy
-        run: cargo clippy --workspace --tests -- -D warnings
+        run: cargo clippy --workspace --release ${{ matrix.features }} -- -D warnings
       - name: Run tests
-        run: cargo test --workspace
+        run: cargo test --workspace --release ${{ matrix.features }}
+
+  doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - name: Install Rust toolchain
+        run: rustup toolchain install stable
       - name: Run docs
-        run: cargo rustdoc --all-features -- -D warnings
+        run: cargo rustdoc --release -- -D warnings
diff --git a/Cargo.toml b/Cargo.toml
index 9287bd5..f46438e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,7 +55,7 @@ uuid = { version = "1.1.0", features = ["serde", "v4"] }
 tonic-build = "0.7.2"
 
 [dev-dependencies]
-tokio = { version = "1.18.2", features = ["rt-multi-thread"] }
+tokio = { version = "1.18.2", features = ["rt-multi-thread", "signal"] }
 tokio-stream = { version = "0.1.8", features = ["net"] }
 
 [[test]]
diff --git a/README.md b/README.md
index 797ba05..a343e5c 100644
--- a/README.md
+++ b/README.md
@@ -81,11 +81,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
     tokio::spawn(handle_request(tracer.clone()));
 
     // Start to report.
-    let handle = tracer.reporting(async move {
-        let _ = signal::ctrl_c().await;
-    });
-
-    handle.await?;
+    tracer
+        .reporting(async move {
+            let _ = signal::ctrl_c().await.unwrap();
+        })
+        .await?;
 
     Ok(())
 }
@@ -104,6 +104,7 @@ use `cargo run --example simple_trace_report`
 which outputs executable, then run it.
 
 # Release
+
 The SkyWalking committer(PMC included) could follow [this doc](Release-guide.md) to release an official version.
 
 # License
diff --git a/e2e/src/main.rs b/e2e/src/main.rs
index 5611d9f..7180235 100644
--- a/e2e/src/main.rs
+++ b/e2e/src/main.rs
@@ -25,7 +25,7 @@ use skywalking::context::tracer::{self, Tracer};
 use skywalking::reporter::grpc::GrpcReporter;
 use std::convert::Infallible;
 use std::error::Error;
-use std::future::pending;
+use std::future;
 use std::net::SocketAddr;
 use structopt::StructOpt;
 
@@ -153,12 +153,12 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let handle = if opt.mode == "consumer" {
         tracer::set_global_tracer(Tracer::new("consumer", "node_0", reporter));
-        let handle = tracer::reporting(pending());
+        let handle = tracer::reporting(future::pending());
         run_consumer_service([0, 0, 0, 0]).await;
         handle
     } else if opt.mode == "producer" {
         tracer::set_global_tracer(Tracer::new("producer", "node_0", reporter));
-        let handle = tracer::reporting(pending());
+        let handle = tracer::reporting(future::pending());
         run_producer_service([0, 0, 0, 0]).await;
         handle
     } else {
diff --git a/examples/simple_trace_report.rs b/examples/simple_trace_report.rs
index f7f321b..c70c10f 100644
--- a/examples/simple_trace_report.rs
+++ b/examples/simple_trace_report.rs
@@ -54,11 +54,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
     tokio::spawn(handle_request(tracer.clone()));
 
     // Start to report.
-    let handle = tracer.reporting(async move {
-        let _ = signal::ctrl_c().await;
-    });
-
-    handle.await?;
+    tracer
+        .reporting(async move {
+            let _ = signal::ctrl_c().await.unwrap();
+        })
+        .await?;
 
     Ok(())
 }
diff --git a/src/context/tracer.rs b/src/context/tracer.rs
index 0a87905..9e14052 100644
--- a/src/context/tracer.rs
+++ b/src/context/tracer.rs
@@ -20,9 +20,12 @@ use crate::{
     skywalking_proto::v3::SegmentObject,
 };
 use std::future::Future;
+use std::pin::Pin;
 use std::sync::Weak;
+use std::task::{Context, Poll};
 use std::{collections::LinkedList, sync::Arc};
 use tokio::sync::OnceCell;
+use tokio::task::JoinError;
 use tokio::{
     sync::{
         mpsc::{self},
@@ -58,9 +61,7 @@ pub fn create_trace_context_from_propagation(context: PropagationContext) -> Tra
 /// Start to reporting by global tracer, quit when shutdown_signal received.
 ///
 /// Accept a `shutdown_signal` argument as a graceful shutdown signal.
-pub fn reporting(
-    shutdown_signal: impl Future<Output = ()> + Send + Sync + 'static,
-) -> JoinHandle<()> {
+pub fn reporting(shutdown_signal: impl Future<Output = ()> + Send + Sync + 'static) -> Reporting {
     global_tracer().reporting(shutdown_signal)
 }
 
@@ -142,8 +143,10 @@ impl Tracer {
     pub fn reporting(
         &self,
         shutdown_signal: impl Future<Output = ()> + Send + Sync + 'static,
-    ) -> JoinHandle<()> {
-        tokio::spawn(Self::do_reporting(self.clone(), shutdown_signal))
+    ) -> Reporting {
+        Reporting {
+            handle: tokio::spawn(self.clone().do_reporting(shutdown_signal)),
+        }
     }
 
     async fn do_reporting(self, shutdown_signal: impl Future<Output = ()> + Send + Sync + 'static) {
@@ -216,6 +219,19 @@ impl WeakTracer {
     }
 }
 
+/// Created by [Tracer::reporting].
+pub struct Reporting {
+    handle: JoinHandle<()>,
+}
+
+impl Future for Reporting {
+    type Output = Result<(), JoinError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.handle).poll(cx)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/reporter/grpc.rs b/src/reporter/grpc.rs
index afdd2d2..fb04364 100644
--- a/src/reporter/grpc.rs
+++ b/src/reporter/grpc.rs
@@ -19,7 +19,7 @@ use crate::skywalking_proto::v3::{
     trace_segment_report_service_client::TraceSegmentReportServiceClient, SegmentObject,
 };
 use futures_util::stream;
-use std::collections::LinkedList;
+use std::{collections::LinkedList, error::Error};
 use tonic::{
     async_trait,
     transport::{self, Channel, Endpoint},
@@ -47,7 +47,7 @@ impl GrpcReporter {
 
 #[async_trait]
 impl Reporter for GrpcReporter {
-    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> crate::Result<()> {
+    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> Result<(), Box<dyn Error>> {
         let stream = stream::iter(segments);
         self.client.collect(stream).await?;
         Ok(())
diff --git a/src/reporter/log.rs b/src/reporter/log.rs
index 39fe7e0..0d002a2 100644
--- a/src/reporter/log.rs
+++ b/src/reporter/log.rs
@@ -16,16 +16,58 @@
 
 use super::Reporter;
 use crate::skywalking_proto::v3::SegmentObject;
-use std::collections::LinkedList;
+use std::{collections::LinkedList, error::Error};
 use tonic::async_trait;
 
-pub struct LogReporter;
+enum Used {
+    Println,
+    Tracing,
+}
+
+pub struct LogReporter {
+    tip: String,
+    used: Used,
+}
+
+impl LogReporter {
+    #[inline]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn tip(mut self, tip: String) -> Self {
+        self.tip = tip;
+        self
+    }
+
+    pub fn use_tracing(mut self) -> Self {
+        self.used = Used::Tracing;
+        self
+    }
+
+    pub fn use_println(mut self) -> Self {
+        self.used = Used::Println;
+        self
+    }
+}
+
+impl Default for LogReporter {
+    fn default() -> Self {
+        Self {
+            tip: "Collect".to_string(),
+            used: Used::Println,
+        }
+    }
+}
 
 #[async_trait]
 impl Reporter for LogReporter {
-    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> crate::Result<()> {
+    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> Result<(), Box<dyn Error>> {
         for segment in segments {
-            tracing::info!(?segment, "Do trace");
+            match self.used {
+                Used::Println => println!("{} segment={:?}", self.tip, segment),
+                Used::Tracing => tracing::info!(?segment, "{}", self.tip),
+            }
         }
         Ok(())
     }
diff --git a/src/reporter/mod.rs b/src/reporter/mod.rs
index c2f9fda..29ea40c 100644
--- a/src/reporter/mod.rs
+++ b/src/reporter/mod.rs
@@ -19,11 +19,12 @@ pub mod log;
 
 use crate::skywalking_proto::v3::SegmentObject;
 use std::collections::LinkedList;
+use std::{error::Error, result::Result};
 use tonic::async_trait;
 
 pub(crate) type DynReporter = dyn Reporter + Send + Sync + 'static;
 
 #[async_trait]
 pub trait Reporter {
-    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> crate::Result<()>;
+    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> Result<(), Box<dyn Error>>;
 }
diff --git a/tests/propagation.rs b/tests/propagation.rs
index bb893c3..e98e057 100644
--- a/tests/propagation.rs
+++ b/tests/propagation.rs
@@ -64,7 +64,7 @@ fn invalid_sample() {
 
 #[test]
 fn basic_encode() {
-    let tracer = Tracer::new("mesh", "instance", LogReporter);
+    let tracer = Tracer::new("mesh", "instance", LogReporter::new());
     let tc = tracer.create_trace_context();
     let res = encode_propagation(&tc, "/api/v1/health", "example.com:8080");
     let res2 = decode_propagation(&res).unwrap();
diff --git a/tests/trace_context.rs b/tests/trace_context.rs
index 0cd992d..d752a59 100644
--- a/tests/trace_context.rs
+++ b/tests/trace_context.rs
@@ -15,10 +15,8 @@
 //
 
 use prost::Message;
-use skywalking::context::propagation::context::PropagationContext;
 use skywalking::context::propagation::decoder::decode_propagation;
 use skywalking::context::propagation::encoder::encode_propagation;
-use skywalking::context::trace_context::TracingContext;
 use skywalking::context::tracer::Tracer;
 use skywalking::reporter::log::LogReporter;
 use skywalking::reporter::Reporter;
@@ -27,10 +25,9 @@ use skywalking::skywalking_proto::v3::{
     SpanType,
 };
 use std::collections::LinkedList;
-use std::sync::Mutex;
-use std::{cell::Ref, sync::Arc};
+use std::error::Error;
+use std::sync::{Arc, Mutex};
 use std::{future, thread};
-use tokio::runtime::Handle;
 
 /// Serialize from A should equal Serialize from B
 #[allow(dead_code)]
@@ -70,7 +67,7 @@ async fn create_span() {
                     })
                     .collect();
                 let expected_log = vec![Log {
-                    time: 100,
+                    time: 10,
                     data: expected_log_message,
                 }];
                 span1.add_log(logs);
@@ -119,19 +116,19 @@ async fn create_span() {
                 }
 
                 {
-                    let span4 = context.create_exit_span("op3", "example.com/test");
+                    let _span4 = context.create_local_span("op4");
 
                     {
-                        let span5 = context.create_exit_span("op4", "example.com/test");
+                        let span5 = context.create_exit_span("op5", "example.com/test");
                         drop(span5);
 
                         let span5_expected = SpanObject {
-                            span_id: 3,
-                            parent_span_id: 2,
-                            start_time: 100,
+                            span_id: 4,
+                            parent_span_id: 3,
+                            start_time: 1,
                             end_time: 100,
                             refs: Vec::<SegmentReference>::new(),
-                            operation_name: "op4".to_string(),
+                            operation_name: "op5".to_string(),
                             peer: "example.com/test".to_string(),
                             span_type: SpanType::Exit as i32,
                             span_layer: SpanLayer::Http as i32,
@@ -152,7 +149,7 @@ async fn create_span() {
                 let span1_expected = SpanObject {
                     span_id: 0,
                     parent_span_id: -1,
-                    start_time: 100,
+                    start_time: 1,
                     end_time: 100,
                     refs: Vec::<SegmentReference>::new(),
                     operation_name: "op1".to_string(),
@@ -185,12 +182,18 @@ async fn create_span() {
 
 #[test]
 #[should_panic]
-fn create_span_failed() {
-    let tracer = Tracer::new("service", "instance", LogReporter);
+fn create_local_span_failed() {
+    let tracer = Tracer::new("service", "instance", LogReporter::new());
     let mut context = tracer.create_trace_context();
+    let _span1 = context.create_local_span("op1");
+}
 
-    let _span1 = context.create_entry_span("op1");
-    let _span2 = context.create_entry_span("op2");
+#[test]
+#[should_panic]
+fn create_exit_span_failed() {
+    let tracer = Tracer::new("service", "instance", LogReporter::new());
+    let mut context = tracer.create_trace_context();
+    let _span1 = context.create_exit_span("op1", "example.com/test");
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -217,7 +220,7 @@ async fn create_span_from_context() {
 
 #[test]
 fn crossprocess_test() {
-    let tracer = Tracer::new("service", "instance", LogReporter);
+    let tracer = Tracer::new("service", "instance", LogReporter::new());
     let mut context1 = tracer.create_trace_context();
     assert_eq!(context1.service(), "service");
     assert_eq!(context1.service_instance(), "instance");
@@ -230,7 +233,7 @@ fn crossprocess_test() {
             let enc_prop = encode_propagation(&context1, "endpoint", "address");
             let dec_prop = decode_propagation(&enc_prop).unwrap();
 
-            let tracer = Tracer::new("service2", "instance2", LogReporter);
+            let tracer = Tracer::new("service2", "instance2", LogReporter::new());
             let mut context2 = tracer.create_trace_context_from_propagation(dec_prop);
 
             let span3 = context2.create_entry_span("op2");
@@ -281,14 +284,14 @@ async fn cross_threads_test() {
             tracer
         },
         |segments| {
-            let iter = segments.iter();
-            let first = iter.nth(0).unwrap();
-            let second = iter.nth(1).unwrap();
+            let mut iter = segments.iter();
+            let first = iter.next().unwrap();
+            let second = iter.next().unwrap();
 
             assert_eq!(first.trace_id, second.trace_id);
-            assert_eq!(first.spans.refs.len(), 1);
+            assert_eq!(first.spans.last().unwrap().refs.len(), 1);
             assert_eq!(
-                first.spans.refs[0],
+                first.spans.last().unwrap().refs[0],
                 SegmentReference {
                     ref_type: RefType::CrossThread as i32,
                     trace_id: second.trace_id.clone(),
@@ -333,7 +336,7 @@ impl MockReporter {
 
 #[tonic::async_trait]
 impl Reporter for MockReporter {
-    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> skywalking::Result<()> {
+    async fn collect(&mut self, segments: LinkedList<SegmentObject>) -> Result<(), Box<dyn Error>> {
         self.segments.try_lock().unwrap().extend(segments);
         Ok(())
     }