Skip to content

pydantic_evals.otel

SpanNode

A node in the span tree; provides references to parents/children for easy traversal and queries.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
 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
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
class SpanNode:
    """A node in the span tree; provides references to parents/children for easy traversal and queries."""

    def __init__(self, span: ReadableSpan):
        self._span = span
        # If a span has no context, it's going to cause problems. We may need to add improved handling of this scenario.
        assert self._span.context is not None, f'{span=} has no context'

        self.parent: SpanNode | None = None
        self.children_by_id: dict[int, SpanNode] = {}  # note: we rely on insertion order to determine child order

    @property
    def children(self) -> list[SpanNode]:
        return list(self.children_by_id.values())

    @property
    def descendants(self) -> list[SpanNode]:
        """Return all descendants of this node in DFS order."""
        descendants: list[SpanNode] = []
        stack = list(self.children)
        while stack:
            node = stack.pop()
            descendants.append(node)
            stack.extend(node.children)
        return descendants

    @property
    def context(self) -> SpanContext:
        """Return the SpanContext of the wrapped span."""
        assert self._span.context is not None
        return self._span.context

    @property
    def parent_context(self) -> SpanContext | None:
        """Return the SpanContext of the parent of the wrapped span."""
        return self._span.parent

    @property
    def span_id(self) -> int:
        """Return the integer span_id from the SpanContext."""
        return self.context.span_id

    @property
    def trace_id(self) -> int:
        """Return the integer trace_id from the SpanContext."""
        return self.context.trace_id

    @property
    def name(self) -> str:
        """Convenience for the span's name."""
        return self._span.name

    @property
    def start_timestamp(self) -> datetime:
        """Return the span's start time as a UTC datetime, or None if not set."""
        assert self._span.start_time is not None
        return datetime.fromtimestamp(self._span.start_time / 1e9, tz=timezone.utc)

    @property
    def end_timestamp(self) -> datetime:
        """Return the span's end time as a UTC datetime, or None if not set."""
        assert self._span.end_time is not None
        return datetime.fromtimestamp(self._span.end_time / 1e9, tz=timezone.utc)

    @property
    def duration(self) -> timedelta:
        """Return the span's duration as a timedelta, or None if start/end not set."""
        return self.end_timestamp - self.start_timestamp

    @property
    def attributes(self) -> Mapping[str, AttributeValue]:
        # Note: It would be nice to expose the non-JSON-serialized versions of (logfire-recorded) attributes with
        # nesting etc. This just exposes the JSON-serialized version, but doing more would be difficult.
        return self._span.attributes or {}

    def add_child(self, child: SpanNode) -> None:
        """Attach a child node to this node's list of children."""
        self.children_by_id[child.span_id] = child
        child.parent = self

    # -------------------------------------------------------------------------
    # Child queries
    # -------------------------------------------------------------------------
    def find_children(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
        """Return all immediate children that satisfy the given predicate."""
        return [child for child in self.children if predicate(child)]

    def first_child(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
        """Return the first immediate child that satisfies the given predicate, or None if none match."""
        for child in self.children:
            if predicate(child):
                return child
        return None

    def any_child(self, predicate: Callable[[SpanNode], bool]) -> bool:
        """Returns True if there is at least one child that satisfies the predicate."""
        return self.first_child(predicate) is not None

    # -------------------------------------------------------------------------
    # Descendant queries (DFS)
    # -------------------------------------------------------------------------
    def find_descendants(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
        """Return all descendant nodes that satisfy the given predicate in DFS order."""
        found: list[SpanNode] = []
        stack = list(self.children)
        while stack:
            node = stack.pop()
            if predicate(node):
                found.append(node)
            stack.extend(node.children)
        return found

    def first_descendant(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
        """DFS: Return the first descendant (in DFS order) that satisfies the given predicate, or `None` if none match."""
        stack = list(self.children)
        while stack:
            node = stack.pop()
            if predicate(node):
                return node
            stack.extend(node.children)
        return None

    def any_descendant(self, predicate: Callable[[SpanNode], bool]) -> bool:
        """Returns `True` if there is at least one descendant that satisfies the predicate."""
        return self.first_descendant(predicate) is not None

    # -------------------------------------------------------------------------
    # Ancestor queries (DFS "up" the chain)
    # -------------------------------------------------------------------------
    def find_ancestors(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
        """Return all ancestors that satisfy the given predicate."""
        found: list[SpanNode] = []
        node = self.parent
        while node:
            if predicate(node):
                found.append(node)
            node = node.parent
        return found

    def first_ancestor(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
        """Return the closest ancestor that satisfies the given predicate, or `None` if none match."""
        node = self.parent
        while node:
            if predicate(node):
                return node
            node = node.parent
        return None

    def any_ancestor(self, predicate: Callable[[SpanNode], bool]) -> bool:
        """Returns True if any ancestor satisfies the predicate."""
        return self.first_ancestor(predicate) is not None

    # -------------------------------------------------------------------------
    # Matching convenience
    # -------------------------------------------------------------------------
    def matches(self, name: str | None = None, attributes: dict[str, Any] | None = None) -> bool:
        """A convenience method to see if this node's span matches certain conditions.

        - name: exact match for the Span name
        - attributes: dict of key->value; must match exactly.
        """
        if name is not None and self.name != name:
            return False
        if attributes:
            span_attributes = self._span.attributes or {}
            for attr_key, attr_val in attributes.items():
                if span_attributes.get(attr_key) != attr_val:
                    return False
        return True

    # -------------------------------------------------------------------------
    # String representation
    # -------------------------------------------------------------------------
    def repr_xml(
        self,
        include_children: bool = True,
        include_span_id: bool = False,
        include_trace_id: bool = False,
        include_start_timestamp: bool = False,
        include_duration: bool = False,
    ) -> str:
        """Return an XML-like string representation of the node.

        Optionally includes children, span_id, trace_id, start_timestamp, and duration.
        """
        first_line_parts = [f'<SpanNode name={self.name!r}']
        if include_span_id:
            first_line_parts.append(f'span_id={self.span_id:016x}')
        if include_trace_id:
            first_line_parts.append(f'trace_id={self.trace_id:032x}')
        if include_start_timestamp:
            first_line_parts.append(f'start_timestamp={self.start_timestamp.isoformat()!r}')
        if include_duration:
            first_line_parts.append(f"duration='{self.duration}'")

        extra_lines: list[str] = []
        if include_children and self.children:
            first_line_parts.append('>')
            for child in self.children:
                extra_lines.append(
                    indent(
                        child.repr_xml(
                            include_children=include_children,
                            include_span_id=include_span_id,
                            include_trace_id=include_trace_id,
                            include_start_timestamp=include_start_timestamp,
                            include_duration=include_duration,
                        ),
                        '  ',
                    )
                )
            extra_lines.append('</SpanNode>')
        else:
            if self.children:
                first_line_parts.append('children=...')
            first_line_parts.append('/>')
        return '\n'.join([' '.join(first_line_parts), *extra_lines])

    def __str__(self) -> str:
        if self.children:
            return f'<SpanNode name={self.name!r} span_id={self.span_id:016x}>...</SpanNode>'
        else:
            return f'<SpanNode name={self.name!r} span_id={self.span_id:016x} />'

    def __repr__(self) -> str:
        return self.repr_xml()

descendants property 

descendants: list[SpanNode]

Return all descendants of this node in DFS order.

context property 

context: SpanContext

Return the SpanContext of the wrapped span.

parent_context property 

parent_context: SpanContext | None

Return the SpanContext of the parent of the wrapped span.

span_id property 

span_id: int

Return the integer span_id from the SpanContext.

trace_id property 

trace_id: int

Return the integer trace_id from the SpanContext.

name property 

name: str

Convenience for the span's name.

start_timestamp property 

start_timestamp: datetime

Return the span's start time as a UTC datetime, or None if not set.

end_timestamp property 

end_timestamp: datetime

Return the span's end time as a UTC datetime, or None if not set.

duration property 

duration: timedelta

Return the span's duration as a timedelta, or None if start/end not set.

add_child 

add_child(child: SpanNode) -> None

Attach a child node to this node's list of children.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
96
97
98
99
def add_child(self, child: SpanNode) -> None:
    """Attach a child node to this node's list of children."""
    self.children_by_id[child.span_id] = child
    child.parent = self

find_children 

find_children(
    predicate: Callable[[SpanNode], bool],
) -> list[SpanNode]

Return all immediate children that satisfy the given predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
104
105
106
def find_children(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
    """Return all immediate children that satisfy the given predicate."""
    return [child for child in self.children if predicate(child)]

first_child 

first_child(
    predicate: Callable[[SpanNode], bool],
) -> SpanNode | None

Return the first immediate child that satisfies the given predicate, or None if none match.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
108
109
110
111
112
113
def first_child(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
    """Return the first immediate child that satisfies the given predicate, or None if none match."""
    for child in self.children:
        if predicate(child):
            return child
    return None

any_child 

any_child(predicate: Callable[[SpanNode], bool]) -> bool

Returns True if there is at least one child that satisfies the predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
115
116
117
def any_child(self, predicate: Callable[[SpanNode], bool]) -> bool:
    """Returns True if there is at least one child that satisfies the predicate."""
    return self.first_child(predicate) is not None

find_descendants 

find_descendants(
    predicate: Callable[[SpanNode], bool],
) -> list[SpanNode]

Return all descendant nodes that satisfy the given predicate in DFS order.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
122
123
124
125
126
127
128
129
130
131
def find_descendants(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
    """Return all descendant nodes that satisfy the given predicate in DFS order."""
    found: list[SpanNode] = []
    stack = list(self.children)
    while stack:
        node = stack.pop()
        if predicate(node):
            found.append(node)
        stack.extend(node.children)
    return found

first_descendant 

first_descendant(
    predicate: Callable[[SpanNode], bool],
) -> SpanNode | None

DFS: Return the first descendant (in DFS order) that satisfies the given predicate, or None if none match.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
133
134
135
136
137
138
139
140
141
def first_descendant(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
    """DFS: Return the first descendant (in DFS order) that satisfies the given predicate, or `None` if none match."""
    stack = list(self.children)
    while stack:
        node = stack.pop()
        if predicate(node):
            return node
        stack.extend(node.children)
    return None

any_descendant 

any_descendant(
    predicate: Callable[[SpanNode], bool],
) -> bool

Returns True if there is at least one descendant that satisfies the predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
143
144
145
def any_descendant(self, predicate: Callable[[SpanNode], bool]) -> bool:
    """Returns `True` if there is at least one descendant that satisfies the predicate."""
    return self.first_descendant(predicate) is not None

find_ancestors 

find_ancestors(
    predicate: Callable[[SpanNode], bool],
) -> list[SpanNode]

Return all ancestors that satisfy the given predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
150
151
152
153
154
155
156
157
158
def find_ancestors(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
    """Return all ancestors that satisfy the given predicate."""
    found: list[SpanNode] = []
    node = self.parent
    while node:
        if predicate(node):
            found.append(node)
        node = node.parent
    return found

first_ancestor 

first_ancestor(
    predicate: Callable[[SpanNode], bool],
) -> SpanNode | None

Return the closest ancestor that satisfies the given predicate, or None if none match.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
160
161
162
163
164
165
166
167
def first_ancestor(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
    """Return the closest ancestor that satisfies the given predicate, or `None` if none match."""
    node = self.parent
    while node:
        if predicate(node):
            return node
        node = node.parent
    return None

any_ancestor 

any_ancestor(predicate: Callable[[SpanNode], bool]) -> bool

Returns True if any ancestor satisfies the predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
169
170
171
def any_ancestor(self, predicate: Callable[[SpanNode], bool]) -> bool:
    """Returns True if any ancestor satisfies the predicate."""
    return self.first_ancestor(predicate) is not None

matches 

matches(
    name: str | None = None,
    attributes: dict[str, Any] | None = None,
) -> bool

A convenience method to see if this node's span matches certain conditions.

  • name: exact match for the Span name
  • attributes: dict of key->value; must match exactly.
Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
176
177
178
179
180
181
182
183
184
185
186
187
188
189
def matches(self, name: str | None = None, attributes: dict[str, Any] | None = None) -> bool:
    """A convenience method to see if this node's span matches certain conditions.

    - name: exact match for the Span name
    - attributes: dict of key->value; must match exactly.
    """
    if name is not None and self.name != name:
        return False
    if attributes:
        span_attributes = self._span.attributes or {}
        for attr_key, attr_val in attributes.items():
            if span_attributes.get(attr_key) != attr_val:
                return False
    return True

repr_xml 

repr_xml(
    include_children: bool = True,
    include_span_id: bool = False,
    include_trace_id: bool = False,
    include_start_timestamp: bool = False,
    include_duration: bool = False,
) -> str

Return an XML-like string representation of the node.

Optionally includes children, span_id, trace_id, start_timestamp, and duration.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
def repr_xml(
    self,
    include_children: bool = True,
    include_span_id: bool = False,
    include_trace_id: bool = False,
    include_start_timestamp: bool = False,
    include_duration: bool = False,
) -> str:
    """Return an XML-like string representation of the node.

    Optionally includes children, span_id, trace_id, start_timestamp, and duration.
    """
    first_line_parts = [f'<SpanNode name={self.name!r}']
    if include_span_id:
        first_line_parts.append(f'span_id={self.span_id:016x}')
    if include_trace_id:
        first_line_parts.append(f'trace_id={self.trace_id:032x}')
    if include_start_timestamp:
        first_line_parts.append(f'start_timestamp={self.start_timestamp.isoformat()!r}')
    if include_duration:
        first_line_parts.append(f"duration='{self.duration}'")

    extra_lines: list[str] = []
    if include_children and self.children:
        first_line_parts.append('>')
        for child in self.children:
            extra_lines.append(
                indent(
                    child.repr_xml(
                        include_children=include_children,
                        include_span_id=include_span_id,
                        include_trace_id=include_trace_id,
                        include_start_timestamp=include_start_timestamp,
                        include_duration=include_duration,
                    ),
                    '  ',
                )
            )
        extra_lines.append('</SpanNode>')
    else:
        if self.children:
            first_line_parts.append('children=...')
        first_line_parts.append('/>')
    return '\n'.join([' '.join(first_line_parts), *extra_lines])

SpanTree

A container that builds a hierarchy of SpanNode objects from a list of finished spans.

You can then search or iterate the tree to make your assertions (using DFS for traversal).

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
class SpanTree:
    """A container that builds a hierarchy of SpanNode objects from a list of finished spans.

    You can then search or iterate the tree to make your assertions (using DFS for traversal).
    """

    def __init__(self, spans: list[ReadableSpan] | None = None):
        self.nodes_by_id: dict[int, SpanNode] = {}
        self.roots: list[SpanNode] = []
        if spans:  # pragma: no cover
            self.add_spans(spans)

    def add_spans(self, spans: list[ReadableSpan]) -> None:
        """Add a list of spans to the tree, rebuilding the tree structure."""
        for span in spans:
            node = SpanNode(span)
            self.nodes_by_id[node.span_id] = node
        self._rebuild_tree()

    def _rebuild_tree(self):
        # Ensure spans are ordered by start_timestamp so that roots and children end up in the right order
        nodes = list(self.nodes_by_id.values())
        nodes.sort(key=lambda node: node.start_timestamp or datetime.min)
        self.nodes_by_id = {node.span_id: node for node in nodes}

        # Build the parent/child relationships
        for node in self.nodes_by_id.values():
            parent_ctx = node.parent_context
            if parent_ctx is not None:
                parent_node = self.nodes_by_id.get(parent_ctx.span_id)
                if parent_node is not None:
                    parent_node.add_child(node)

        # Determine the roots
        # A node is a "root" if its parent is None or if its parent's span_id is not in the current set of spans.
        self.roots = []
        for node in self.nodes_by_id.values():
            parent_ctx = node.parent_context
            if parent_ctx is None or parent_ctx.span_id not in self.nodes_by_id:
                self.roots.append(node)

    def flattened(self) -> list[SpanNode]:
        """Return a list of all nodes in the tree."""
        return list(self.nodes_by_id.values())

    def find_all(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
        """Find all nodes in the entire tree that match the predicate, scanning from each root in DFS order."""
        result: list[SpanNode] = []
        stack = self.roots[:]
        while stack:
            node = stack.pop()
            if predicate(node):
                result.append(node)
            stack.extend(node.children)
        return result

    def find_first(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
        """Find the first node that matches a predicate, scanning from each root in DFS order. Returns `None` if not found."""
        stack = self.roots[:]
        while stack:
            node = stack.pop()
            if predicate(node):
                return node
            stack.extend(node.children)
        return None

    def any(self, predicate: Callable[[SpanNode], bool]) -> bool:
        """Returns True if any node in the tree matches the predicate."""
        return self.find_first(predicate) is not None

    def __str__(self):
        return f'<SpanTree num_roots={len(self.roots)} total_spans={len(self.nodes_by_id)} />'

    def repr_xml(
        self,
        include_children: bool = True,
        include_span_id: bool = False,
        include_trace_id: bool = False,
        include_start_timestamp: bool = False,
        include_duration: bool = False,
    ) -> str:
        """Return an XML-like string representation of the tree, optionally including children, span_id, trace_id, duration, and timestamps."""
        if not self.roots:
            return '<SpanTree />'
        repr_parts = [
            '<SpanTree>',
            *[
                indent(
                    root.repr_xml(
                        include_children=include_children,
                        include_span_id=include_span_id,
                        include_trace_id=include_trace_id,
                        include_start_timestamp=include_start_timestamp,
                        include_duration=include_duration,
                    ),
                    '  ',
                )
                for root in self.roots
            ],
            '</SpanTree>',
        ]
        return '\n'.join(repr_parts)

    def __repr__(self):
        return self.repr_xml()

add_spans 

add_spans(spans: list[ReadableSpan]) -> None

Add a list of spans to the tree, rebuilding the tree structure.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
261
262
263
264
265
266
def add_spans(self, spans: list[ReadableSpan]) -> None:
    """Add a list of spans to the tree, rebuilding the tree structure."""
    for span in spans:
        node = SpanNode(span)
        self.nodes_by_id[node.span_id] = node
    self._rebuild_tree()

flattened 

flattened() -> list[SpanNode]

Return a list of all nodes in the tree.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
290
291
292
def flattened(self) -> list[SpanNode]:
    """Return a list of all nodes in the tree."""
    return list(self.nodes_by_id.values())

find_all 

find_all(
    predicate: Callable[[SpanNode], bool],
) -> list[SpanNode]

Find all nodes in the entire tree that match the predicate, scanning from each root in DFS order.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
294
295
296
297
298
299
300
301
302
303
def find_all(self, predicate: Callable[[SpanNode], bool]) -> list[SpanNode]:
    """Find all nodes in the entire tree that match the predicate, scanning from each root in DFS order."""
    result: list[SpanNode] = []
    stack = self.roots[:]
    while stack:
        node = stack.pop()
        if predicate(node):
            result.append(node)
        stack.extend(node.children)
    return result

find_first 

find_first(
    predicate: Callable[[SpanNode], bool],
) -> SpanNode | None

Find the first node that matches a predicate, scanning from each root in DFS order. Returns None if not found.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
305
306
307
308
309
310
311
312
313
def find_first(self, predicate: Callable[[SpanNode], bool]) -> SpanNode | None:
    """Find the first node that matches a predicate, scanning from each root in DFS order. Returns `None` if not found."""
    stack = self.roots[:]
    while stack:
        node = stack.pop()
        if predicate(node):
            return node
        stack.extend(node.children)
    return None

any 

any(predicate: Callable[[SpanNode], bool]) -> bool

Returns True if any node in the tree matches the predicate.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
315
316
317
def any(self, predicate: Callable[[SpanNode], bool]) -> bool:
    """Returns True if any node in the tree matches the predicate."""
    return self.find_first(predicate) is not None

repr_xml 

repr_xml(
    include_children: bool = True,
    include_span_id: bool = False,
    include_trace_id: bool = False,
    include_start_timestamp: bool = False,
    include_duration: bool = False,
) -> str

Return an XML-like string representation of the tree, optionally including children, span_id, trace_id, duration, and timestamps.

Source code in pydantic_evals/pydantic_evals/otel/span_tree.py 
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
def repr_xml(
    self,
    include_children: bool = True,
    include_span_id: bool = False,
    include_trace_id: bool = False,
    include_start_timestamp: bool = False,
    include_duration: bool = False,
) -> str:
    """Return an XML-like string representation of the tree, optionally including children, span_id, trace_id, duration, and timestamps."""
    if not self.roots:
        return '<SpanTree />'
    repr_parts = [
        '<SpanTree>',
        *[
            indent(
                root.repr_xml(
                    include_children=include_children,
                    include_span_id=include_span_id,
                    include_trace_id=include_trace_id,
                    include_start_timestamp=include_start_timestamp,
                    include_duration=include_duration,
                ),
                '  ',
            )
            for root in self.roots
        ],
        '</SpanTree>',
    ]
    return '\n'.join(repr_parts)