freeswitch-log-parser 0.17.1

Parser for FreeSWITCH log files — handles compressed .xz files, multi-line dumps, truncated buffers, and stateful UUID/timestamp tracking
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
83
84
85
86
87
88
89
90

//! Message shapes the tracker reads out of dialplan, originate and bridge lines.

use std::str::FromStr;

use freeswitch_types::{BridgeDialString, DialString};

use crate::fields::processing_parts;
use crate::message::new_channel_name;

pub(super) struct DialplanContext {
    pub(super) from: String,
    /// Display name of the caller side, `None` unless the line brackets a number.
    pub(super) from_name: Option<String>,
    /// Number inside the caller side's `<>`, brackets excluded.
    pub(super) from_number: Option<String>,
    pub(super) to: String,
    pub(super) context: String,
}

/// The context of a `parsing [<context>-><extension>]` line.
///
/// The extension is deliberately dropped: it names a dialplan entry point, not
/// the dialed number `dialplan_to` carries, and folding the two into one field
/// left it meaning whichever shape was logged last.
pub(super) fn parse_dialplan_context(detail: &str) -> Option<&str> {
    let rest = detail.strip_prefix("parsing [")?;
    let bracket_end = rest.find(']')?;
    let inner = &rest[..bracket_end];
    let arrow = inner.find("->")?;
    Some(&inner[..arrow])
}

pub(super) fn parse_processing_line(msg: &str) -> Option<DialplanContext> {
    let parts = processing_parts(msg)?;
    Some(DialplanContext {
        from: msg[parts.head].to_string(),
        from_name: parts.name.map(|r| msg[r].to_string()),
        from_number: parts.number.map(|r| msg[r].to_string()),
        to: msg[parts.dest].to_string(),
        context: msg[parts.context].to_string(),
    })
}

pub(super) fn parse_new_channel(detail: &str) -> Option<&str> {
    new_channel_name(detail)
}

/// The cause in the last bracket of a `Hangup <channel> [<state>] [<cause>]`
/// detail. The line's shape is the classifier's finding, not this one's.
pub(super) fn parse_hangup(detail: &str) -> Option<&str> {
    let start = detail.rfind('[')?;
    let end = detail[start..].find(']')?;
    Some(&detail[start + 1..start + end])
}

/// Extract `origination_uuid` and the bridge target channel from bridge() arguments.
/// Uses `BridgeDialString` from freeswitch-types for correct parsing of `[]`, `{}`,
/// `|` failover, and `,` simultaneous ring syntax.
///
/// Returns `None` when the arguments do not parse as a dial string or name no
/// endpoint at all.
pub fn parse_bridge_args(arguments: &str) -> Option<BridgeInfo> {
    let dial = BridgeDialString::from_str(arguments).ok()?;
    let first_ep = dial.groups().first()?.first()?;
    // `{}` variables apply to every endpoint, so a single-leg bridge can name
    // the new leg's UUID there instead of in the endpoint's own `[]`.
    let origination_uuid = first_ep
        .variables()
        .and_then(|v| v.get("origination_uuid"))
        .or_else(|| dial.variables().and_then(|v| v.get("origination_uuid")))
        .map(|s| s.to_string());
    let mut bare = first_ep.clone();
    bare.set_variables(None);
    let target_channel = bare.to_string();
    Some(BridgeInfo {
        origination_uuid,
        target_channel,
    })
}

/// What a `bridge()` argument list says about the leg it is about to create.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct BridgeInfo {
    /// The UUID the new leg is being forced to take, when the dial string sets one.
    pub origination_uuid: Option<String>,
    /// The first endpoint with its `{}`/`[]` variables removed, matching the form
    /// the new channel will report as its channel name.
    pub target_channel: String,
}