You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by ma...@apache.org on 2024/01/22 17:44:25 UTC
(opendal) 01/01: feat(layers/dtrace): Support User Statically-Defined Tracing(aka USDT) on Linux
This is an automated email from the ASF dual-hosted git repository.
manjusaka pushed a commit to branch manjusaka/support-dtrace-layers
in repository https://gitbox.apache.org/repos/asf/opendal.git
commit 4a021c8c5847c7c0c58bebce324c9f1443abea78
Author: Manjusaka <me...@manjusaka.me>
AuthorDate: Tue Jan 23 01:44:05 2024 +0800
feat(layers/dtrace): Support User Statically-Defined Tracing(aka USDT) on Linux
Signed-off-by: Manjusaka <me...@manjusaka.me>
---
Cargo.lock | 7 ++
core/Cargo.toml | 4 +
core/src/layers/dtrace.rs | 227 ++++++++++++++++++++++++++++++++++++++++++++++
core/src/layers/mod.rs | 6 ++
4 files changed, 244 insertions(+)
diff --git a/Cargo.lock b/Cargo.lock
index 0381b429dd..2a6e9e9b99 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4688,6 +4688,7 @@ dependencies = [
"percent-encoding",
"persy",
"pretty_assertions",
+ "probe",
"prometheus",
"prometheus-client",
"prost 0.11.9",
@@ -5427,6 +5428,12 @@ dependencies = [
"indexmap 1.9.3",
]
+[[package]]
+name = "probe"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8e2d2444b730c8f027344c60f9e1f1554d7a3342df9bdd425142ed119a6e5a3"
+
[[package]]
name = "proc-macro-crate"
version = "1.3.1"
diff --git a/core/Cargo.toml b/core/Cargo.toml
index ec73bb4939..f30b4c7022 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -110,6 +110,8 @@ layers-throttle = ["dep:governor"]
layers-await-tree = ["dep:await-tree"]
# Enable layers async-backtrace support.
layers-async-backtrace = ["dep:async-backtrace"]
+# Enable dtrace support.
+layers-dtrace=["dep:probe"]
services-alluxio = []
services-atomicserver = ["dep:atomic_lib"]
@@ -360,6 +362,8 @@ prometheus = { version = "0.13", features = ["process"], optional = true }
prometheus-client = { version = "0.22.0", optional = true }
# for layers-tracing
tracing = { version = "0.1", optional = true }
+# for layers-dtrace
+probe = { version = "0.5.1", optional = true }
[target.'cfg(target_arch = "wasm32")'.dependencies]
getrandom = { version = "0.2", features = ["js"] }
diff --git a/core/src/layers/dtrace.rs b/core/src/layers/dtrace.rs
new file mode 100644
index 0000000000..702c2e4978
--- /dev/null
+++ b/core/src/layers/dtrace.rs
@@ -0,0 +1,227 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use async_trait::async_trait;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+
+use crate::raw::*;
+use crate::*;
+use std::ffi:: CString;
+
+/// Support User Statically-Defined Tracing(aka USDT) on Linux
+///
+/// This layer is a experimental feature, it will be enabled by `features = ["layers-dtrace"]` in Cargo.toml.
+///
+/// Example:
+/// ```
+///
+/// use anyhow::Result;
+/// use opendal::services::Fs;
+/// use opendal::Operator;
+/// use opendal::layers::DTraceLayer;
+///
+/// #[tokio::main]
+/// async fn main() -> Result<()> {
+/// let mut builder = Fs::default();
+///
+/// builder.root("/tmp");
+///
+/// // `Accessor` provides the low level APIs, we will use `Operator` normally.
+/// let op: Operator = Operator::new(builder)?.layer(DTraceLayer{}).finish();
+///
+/// let path="/tmp/test.txt";
+/// for _ in 1..100000{
+/// let bs = vec![0; 64 * 1024 * 1024];
+/// op.write(path, bs).await?;
+/// op.read(path).await?;
+/// }
+/// Ok(())
+/// }
+/// ```
+///
+/// Then you can use `readelf -n target/debug/examples/dtrace` to see the probes:
+///
+/// ```text
+/// Displaying notes found in: .note.stapsdt
+/// Owner Data size Description
+/// stapsdt 0x00000039 NT_STAPSDT (SystemTap probe descriptors)
+/// Provider: opendal
+/// Name: create_dir_start
+/// Location: 0x00000000000f8f05, Base: 0x0000000000000000, Semaphore: 0x00000000003649f8
+/// Arguments: -8@%rax
+/// stapsdt 0x00000037 NT_STAPSDT (SystemTap probe descriptors)
+/// Provider: opendal
+/// Name: create_dir_end
+/// Location: 0x00000000000f9284, Base: 0x0000000000000000, Semaphore: 0x00000000003649fa
+/// Arguments: -8@%rax
+/// stapsdt 0x0000003c NT_STAPSDT (SystemTap probe descriptors)
+/// Provider: opendal
+/// Name: blocking_list_start
+/// Location: 0x00000000000f9487, Base: 0x0000000000000000, Semaphore: 0x0000000000364a28
+/// Arguments: -8@%rax
+/// stapsdt 0x0000003a NT_STAPSDT (SystemTap probe descriptors)
+/// Provider: opendal
+/// Name: blocking_list_end
+/// Location: 0x00000000000f9546, Base: 0x0000000000000000, Semaphore: 0x0000000000364a2a
+/// Arguments: -8@%rax
+/// stapsdt 0x0000003c NT_STAPSDT (SystemTap probe descriptors)
+/// ```
+#[derive(Default, Debug, Clone)]
+pub struct DTraceLayer {}
+
+impl<A: Accessor> Layer<A> for DTraceLayer {
+ type LayeredAccessor = DTraceAccessor<A>;
+ fn layer(&self, inner: A) -> Self::LayeredAccessor {
+ DTraceAccessor { inner }
+ }
+}
+
+#[derive(Clone)]
+pub struct DTraceAccessor<A: Accessor> {
+ inner: A,
+}
+
+impl<A: Accessor> Debug for DTraceAccessor<A> {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("DTraceAccessor")
+ .field("inner", &self.inner)
+ .finish_non_exhaustive()
+ }
+}
+
+#[async_trait]
+impl<A: Accessor> LayeredAccessor for DTraceAccessor<A> {
+ type Inner = A;
+ type Reader = A::Reader;
+ type BlockingReader = A::BlockingReader;
+ type Writer = A::Writer;
+ type BlockingWriter = A::BlockingWriter;
+ type Lister = A::Lister;
+ type BlockingLister = A::BlockingLister;
+ fn inner(&self) -> &Self::Inner {
+ &self.inner
+ }
+
+ async fn create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, create_dir_start, c_path.as_ptr());
+ let create_res = self.inner.create_dir(path, args).await;
+ probe::probe_lazy!(opendal, create_dir_end, c_path.as_ptr());
+ create_res
+ }
+
+ async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, read_start, c_path.as_ptr());
+ let read_res = self.inner.read(path, args).await;
+ probe::probe_lazy!(opendal, read_end, c_path.as_ptr());
+ read_res
+ }
+
+ async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, write_start, c_path.as_ptr());
+ let write_res = self.inner.write(path, args).await;
+ probe::probe_lazy!(opendal, write_end, c_path.as_ptr());
+ write_res
+ }
+
+ async fn stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, stat_start, c_path.as_ptr());
+ let stat_res = self.inner.stat(path, args).await;
+ probe::probe_lazy!(opendal, stat_end, c_path.as_ptr());
+ stat_res
+ }
+
+ async fn delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, delete_start, c_path.as_ptr());
+ let delete_res = self.inner.delete(path, args).await;
+ probe::probe_lazy!(opendal, delete_end, c_path.as_ptr());
+ delete_res
+ }
+
+ async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, list_start, c_path.as_ptr());
+ let list_res = self.inner.list(path, args).await;
+ probe::probe_lazy!(opendal, list_end, c_path.as_ptr());
+ list_res
+ }
+
+ async fn batch(&self, args: OpBatch) -> Result<RpBatch> {
+ self.inner.batch(args).await
+ }
+
+ async fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, presign_start, c_path.as_ptr());
+ let result = self.inner.presign(path, args).await;
+ probe::probe_lazy!(opendal, presign_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_create_dir_start, c_path.as_ptr());
+ let result = self.inner.blocking_create_dir(path, args);
+ probe::probe_lazy!(opendal, blocking_create_dir_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::BlockingReader)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_read_start, c_path.as_ptr());
+ let result = self.inner.blocking_read(path, args);
+ probe::probe_lazy!(opendal, blocking_read_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::BlockingWriter)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_write_start, c_path.as_ptr());
+ let result = self.inner.blocking_write(path, args);
+ probe::probe_lazy!(opendal, blocking_write_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_stat_start, c_path.as_ptr());
+ let result = self.inner.blocking_stat(path, args);
+ probe::probe_lazy!(opendal, blocking_stat_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_delete_start, c_path.as_ptr());
+ let result = self.inner.blocking_delete(path, args);
+ probe::probe_lazy!(opendal, blocking_delete_end, c_path.as_ptr());
+ result
+ }
+
+ fn blocking_list(&self, path: &str, args: OpList) -> Result<(RpList, Self::BlockingLister)> {
+ let c_path = CString::new(path).unwrap();
+ probe::probe_lazy!(opendal, blocking_list_start, c_path.as_ptr());
+ let result = self.inner.blocking_list(path, args);
+ probe::probe_lazy!(opendal, blocking_list_end, c_path.as_ptr());
+ result
+ }
+}
diff --git a/core/src/layers/mod.rs b/core/src/layers/mod.rs
index 7c064cdcf9..5680f81800 100644
--- a/core/src/layers/mod.rs
+++ b/core/src/layers/mod.rs
@@ -101,3 +101,9 @@ pub use self::await_tree::AwaitTreeLayer;
mod async_backtrace;
#[cfg(feature = "layers-async-backtrace")]
pub use self::async_backtrace::AsyncBacktraceLayer;
+
+#[cfg(all(target_os = "linux", feature = "layers-dtrace"))]
+mod dtrace;
+
+#[cfg(all(target_os = "linux", feature = "layers-dtrace"))]
+pub use self::dtrace::DTraceLayer;