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(())
}