///|
let trace_state_limit = 32
///|
let baggage_entry_limit = 64
///|
let baggage_length_limit = 8192
///|
fn duplicate_pairs(
entries : Array[(String, String)],
) -> Array[(String, String)] {
let result : Array[(String, String)] = []
for entry in entries {
result.push(entry)
}
result
}
///|
fn duplicate_baggage_entries(
entries : Array[BaggageEntry],
) -> Array[BaggageEntry] {
let result : Array[BaggageEntry] = []
for entry in entries {
result.push(entry)
}
result
}
///|
fn is_trace_state_key_char(ch : Char) -> Bool {
ch.is_ascii_lowercase() ||
ch.is_ascii_digit() ||
ch is ('_' | '-' | '*' | '/' | '@')
}
///|
fn valid_trace_state_key(key : StringView) -> Bool {
if key.is_empty() || key.length() > 256 {
return false
}
let mut at_count = 0
for index, ch in key.iter2() {
if !is_trace_state_key_char(ch) {
return false
}
if index == 0 && !(ch.is_ascii_lowercase() || ch.is_ascii_digit()) {
return false
}
if ch == '@' {
at_count += 1
if at_count > 1 || index + 1 >= key.length() {
return false
}
}
}
true
}
///|
fn valid_trace_state_value(value : StringView) -> Bool {
if value.length() > 256 {
return false
}
for ch in value {
if ch == ',' || ch == '=' {
return false
}
if !(ch.is_ascii_graphic() || ch == ' ') {
return false
}
}
true
}
///|
fn valid_baggage_name(name : StringView) -> Bool {
if name.is_empty() {
return false
}
for ch in name {
if !ch.is_ascii_graphic() {
return false
}
if ch
is ('('
| ')'
| ','
| '/'
| ':'
| ';'
| '<'
| '='
| '>'
| '?'
| '@'
| '['
| '\\'
| ']'
| '{'
| '}'
| '"') {
return false
}
}
true
}
///|
fn valid_baggage_metadata(metadata : StringView) -> Bool {
for ch in metadata {
if ch == ',' {
return false
}
if !(ch.is_ascii_graphic() || ch == ' ') {
return false
}
}
true
}
///|
fn hex_digit(value : Int32) -> Byte {
"0123456789ABCDEF".code_unit_at(value).to_byte()
}
///|
fn decode_hex_digit(ch : Char) -> Int32? {
if ch.is_ascii_digit() {
Some(ch.to_int() - '0'.to_int())
} else if ch.is_ascii_lowercase() && ch <= 'f' {
Some(ch.to_int() - 'a'.to_int() + 10)
} else if ch.is_ascii_uppercase() && ch <= 'F' {
Some(ch.to_int() - 'A'.to_int() + 10)
} else {
None
}
}
///|
fn percent_encode(input : String) -> String {
let bytes = @utf8.encode(input)
let out : Array[Byte] = []
for b in bytes {
let ch = b.to_char()
if ch.is_ascii_digit() ||
ch.is_ascii_lowercase() ||
ch.is_ascii_uppercase() ||
ch is ('-' | '.' | '_' | '~') {
out.push(b)
} else {
let n = b.to_int()
out.push(b'%')
out.push(hex_digit((n >> 4) & 0x0F))
out.push(hex_digit(n & 0x0F))
}
}
@utf8.decode_lossy(Bytes::from_array(out)[:])
}
///|
fn percent_decode(input : StringView) -> String? {
let chars = input.to_array()
let bytes : Array[Byte] = []
let mut index = 0
while index < chars.length() {
let ch = chars[index]
if ch == '%' {
guard index + 2 < chars.length() else { return None }
guard decode_hex_digit(chars[index + 1]) is Some(high) else {
return None
}
guard decode_hex_digit(chars[index + 2]) is Some(low) else { return None }
bytes.push(((high << 4) | low).to_byte())
index += 3
} else {
for byte in @utf8.encode(ch.to_string()) {
bytes.push(byte)
}
index += 1
}
}
let decoded = @utf8.decode(Bytes::from_array(bytes)[:]) catch {
_ => return None
}
Some(decoded)
}
///|
/// Ordered W3C `tracestate` members carried alongside the current trace.
pub struct TraceState {
priv entries : Array[(String, String)]
} derive(Eq, Compare, Hash, Debug)
///|
#deprecated
#doc(hidden)
pub extend TraceState with Eq::{not_equal, equal}
///|
#deprecated
#doc(hidden)
pub extend TraceState with Compare::{op_lt, op_le, op_ge, compare, op_gt}
///|
#deprecated
#doc(hidden)
pub extend TraceState with Hash::{hash, hash_combine}
///|
#deprecated
#doc(hidden)
pub extend TraceState with Debug::{to_repr}
///|
pub impl Default for TraceState with fn default() {
{ entries: [], }
}
///|
#deprecated
#doc(hidden)
pub extend TraceState with Default::{default}
///|
pub fn TraceState::empty() -> TraceState {
Default::default()
}
///|
pub fn TraceState::is_empty(self : TraceState) -> Bool {
self.entries.is_empty()
}
///|
pub fn TraceState::entries(self : TraceState) -> Array[(String, String)] {
duplicate_pairs(self.entries)
}
///|
pub fn TraceState::get(self : TraceState, key : StringView) -> String? {
for entry in self.entries {
let (entry_key, entry_value) = entry
if entry_key == key.to_owned() {
return Some(entry_value)
}
}
None
}
///|
pub fn TraceState::header(self : TraceState) -> String {
let builder = StringBuilder()
for index = 0; index < self.entries.length(); index = index + 1 {
if index > 0 {
builder.write_char(',')
}
let (key, value) = self.entries[index]
builder.write_string(key)
builder.write_char('=')
builder.write_string(value)
}
builder.to_string()
}
///|
pub fn TraceState::from_header(header : StringView) -> TraceState? {
let header = header.trim()
if header.is_empty() {
return Some(TraceState::empty())
}
let entries : Array[(String, String)] = []
let seen : Map[String, Bool] = Map([])
for item in header.split(",") {
let item = item.trim()
guard !item.is_empty() else { return None }
guard item.split_once("=") is Some((key, value)) else { return None }
let key = key.trim()
let value = value.trim()
guard valid_trace_state_key(key) else { return None }
guard valid_trace_state_value(value) else { return None }
guard !seen.contains(key.to_owned()) else { return None }
entries.push((key.to_owned(), value.to_owned()))
seen[key.to_owned()] = true
}
guard entries.length() <= trace_state_limit else { return None }
Some({ entries, })
}
///|
pub fn TraceState::insert(
self : TraceState,
key : String,
value : String,
) -> TraceState? {
guard valid_trace_state_key(key) else { return None }
guard valid_trace_state_value(value) else { return None }
let entries : Array[(String, String)] = [(key, value)]
for entry in self.entries {
if entry.0 != key {
entries.push(entry)
}
}
guard entries.length() <= trace_state_limit else { return None }
Some({ entries, })
}
///|
pub fn TraceState::remove(self : TraceState, key : StringView) -> TraceState {
let entries : Array[(String, String)] = []
for entry in self.entries {
if entry.0 != key.to_owned() {
entries.push(entry)
}
}
{ entries, }
}
///|
/// A single W3C baggage member.
pub struct BaggageEntry {
name : String
value : String
metadata : String?
} derive(Eq, Compare, Hash, Debug)
///|
#deprecated
#doc(hidden)
pub extend BaggageEntry with Eq::{not_equal, equal}
///|
#deprecated
#doc(hidden)
pub extend BaggageEntry with Compare::{op_lt, op_le, op_ge, compare, op_gt}
///|
#deprecated
#doc(hidden)
pub extend BaggageEntry with Hash::{hash, hash_combine}
///|
#deprecated
#doc(hidden)
pub extend BaggageEntry with Debug::{to_repr}
///|
fn BaggageEntry::header(self : BaggageEntry) -> String {
let builder = StringBuilder()
builder.write_string(self.name)
builder.write_char('=')
builder.write_string(percent_encode(self.value))
if self.metadata is Some(metadata) {
if metadata != "" {
builder.write_char(';')
builder.write_string(metadata)
}
}
builder.to_string()
}
///|
/// Ordered baggage members carried by a trace context.
pub struct Baggage {
priv entries : Array[BaggageEntry]
} derive(Eq, Compare, Hash, Debug)
///|
#deprecated
#doc(hidden)
pub extend Baggage with Eq::{not_equal, equal}
///|
#deprecated
#doc(hidden)
pub extend Baggage with Compare::{op_lt, op_le, op_ge, compare, op_gt}
///|
#deprecated
#doc(hidden)
pub extend Baggage with Hash::{hash, hash_combine}
///|
#deprecated
#doc(hidden)
pub extend Baggage with Debug::{to_repr}
///|
pub impl Default for Baggage with fn default() {
{ entries: [], }
}
///|
#deprecated
#doc(hidden)
pub extend Baggage with Default::{default}
///|
pub fn Baggage::empty() -> Baggage {
Default::default()
}
///|
pub fn Baggage::is_empty(self : Baggage) -> Bool {
self.entries.is_empty()
}
///|
pub fn Baggage::entries(self : Baggage) -> Array[BaggageEntry] {
duplicate_baggage_entries(self.entries)
}
///|
pub fn Baggage::get(self : Baggage, name : StringView) -> BaggageEntry? {
for entry in self.entries {
if entry.name == name.to_owned() {
return Some(entry)
}
}
None
}
///|
pub fn Baggage::header(self : Baggage) -> String {
let builder = StringBuilder()
for index = 0; index < self.entries.length(); index = index + 1 {
if index > 0 {
builder.write_char(',')
}
builder.write_string(self.entries[index].header())
}
builder.to_string()
}
///|
fn baggage_with_entries(entries : Array[BaggageEntry]) -> Baggage? {
guard entries.length() <= baggage_entry_limit else { return None }
let baggage : Baggage = { entries, }
guard baggage.header().length() <= baggage_length_limit else { return None }
Some(baggage)
}
///|
pub fn Baggage::from_header(header : StringView) -> Baggage? {
let header = header.trim()
if header.is_empty() {
return Some(Baggage::empty())
}
let entries : Array[BaggageEntry] = []
let seen : Map[String, Bool] = Map([])
for item in header.split(",") {
let item = item.trim()
guard !item.is_empty() else { return None }
let (pair, metadata) = match item.find(";") {
Some(index) =>
(item[:index].trim(), Some(item[index + 1:].trim().to_owned()))
None => (item, None)
}
guard pair.split_once("=") is Some((name, encoded_value)) else {
return None
}
let name = name.trim()
let encoded_value = encoded_value.trim()
guard valid_baggage_name(name) else { return None }
guard !seen.contains(name.to_owned()) else { return None }
guard percent_decode(encoded_value) is Some(value) else { return None }
guard metadata is None || valid_baggage_metadata(metadata.unwrap()) else {
return None
}
entries.push({ name: name.to_owned(), value, metadata, })
seen[name.to_owned()] = true
}
baggage_with_entries(entries)
}
///|
pub fn Baggage::insert(
self : Baggage,
name : String,
value : String,
metadata? : String,
) -> Baggage? {
guard valid_baggage_name(name) else { return None }
guard metadata is None || valid_baggage_metadata(metadata.unwrap()) else {
return None
}
let entries : Array[BaggageEntry] = [{ name, value, metadata, }]
for entry in self.entries {
if entry.name != name {
entries.push(entry)
}
}
baggage_with_entries(entries)
}
///|
pub fn Baggage::remove(self : Baggage, name : StringView) -> Baggage {
let entries : Array[BaggageEntry] = []
for entry in self.entries {
if entry.name != name.to_owned() {
entries.push(entry)
}
}
{ entries, }
}
///|
/// Immutable span identity used for parenting, linking, and propagation.
///
/// `SpanContext` is safe to copy and pass across tasks because it does not own
/// span lifecycle operations.
///
/// `trace_flags`, `trace_state`, and `is_remote` make the value sufficient for
/// W3C propagation and OpenTelemetry linking.
#alias(SpanRef)
pub struct SpanContext {
trace_id : TraceId
span_id : SpanId
trace_flags : TraceFlags
trace_state : TraceState
is_remote : Bool
} derive(Eq, Compare, Hash, Debug)
///|
#deprecated
#doc(hidden)
pub extend SpanContext with Eq::{not_equal, equal}
///|
#deprecated
#doc(hidden)
pub extend SpanContext with Compare::{op_lt, op_le, op_ge, compare, op_gt}
///|
#deprecated
#doc(hidden)
pub extend SpanContext with Hash::{hash, hash_combine}
///|
#deprecated
#doc(hidden)
pub extend SpanContext with Debug::{to_repr}
///|
pub fn SpanContext::invalid() -> SpanContext {
{
trace_id: TraceId::invalid(),
span_id: SpanId::invalid(),
trace_flags: TraceFlags::not_sampled(),
trace_state: TraceState::empty(),
is_remote: false,
}
}
///|
pub fn SpanContext::new(
trace_id : TraceId,
span_id : SpanId,
trace_flags~ : TraceFlags = TraceFlags::sampled(),
trace_state~ : TraceState = TraceState::empty(),
is_remote~ : Bool = false,
) -> SpanContext {
{ trace_id, span_id, trace_flags, trace_state, is_remote, }
}
///|
pub fn SpanContext::is_valid(self : SpanContext) -> Bool {
!self.trace_id.is_zero() && !self.span_id.is_zero()
}