pyroscope 2.0.0

Pyroscope Profiler Agent for continuous profiling of Rust, Python and Ruby applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use super::{StackTrace, Tag};
use crate::error::Result;
use std::collections::HashSet;
use std::sync::{Arc, Mutex};

#[derive(Debug, Eq, PartialEq, Hash, Clone)]
pub struct ThreadTag {
    tid: crate::utils::ThreadId,
    tag: Tag,
}

impl ThreadTag {
    pub fn new(tid: crate::ThreadId, tag: Tag) -> Self {
        Self { tid, tag }
    }
}

#[derive(Debug, Default, Clone)]
pub struct ThreadTagsSet {
    pub rules: Arc<Mutex<HashSet<ThreadTag>>>,
}

impl ThreadTagsSet {
    pub fn new() -> Self {
        Self {
            rules: Arc::new(Mutex::new(HashSet::new())),
        }
    }

    pub fn add(&self, rule: ThreadTag) -> Result<bool> {
        let rules = self.rules.clone();

        let insert = rules.lock()?.insert(rule);

        Ok(insert)
    }

    pub fn remove(&self, rule: ThreadTag) -> Result<bool> {
        let rules = self.rules.clone();

        let remove = rules.lock()?.remove(&rule);

        Ok(remove)
    }

    #[cfg(test)]
    pub fn thread_tags(&self, tid: crate::ThreadId) -> Vec<Tag> {
        let s = StackTrace {
            pid: None,
            thread_id: Some(tid.clone()),
            thread_name: None,
            frames: vec![],
            metadata: Default::default(),
        };
        let tags: Vec<Tag> = s.add_tag_rules(self).metadata.tags.into_iter().collect();
        tags
    }
}

impl StackTrace {
    pub fn add_tag_rules(self, other: &ThreadTagsSet) -> Self {
        let mut metadata = self.metadata;

        if let Ok(rules) = other.rules.lock() {
            rules.iter().for_each(|rule| {
                if let Some(stack_thread_id) = &self.thread_id {
                    if rule.tid == *stack_thread_id {
                        metadata.add_tag(rule.tag.clone());
                    }
                }
            })
        }

        Self {
            pid: self.pid,
            thread_id: self.thread_id,
            thread_name: self.thread_name,
            frames: self.frames,
            metadata,
        }
    }
}