robotframework-events 0.1.0__tar.gz

robotframework_events-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim de Groot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_events-0.1.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: robotframework-events
+Version: 0.1.0
+Summary: Robot Framework listener that writes execution events as JSON Lines
+Author: Tim de Groot
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/timdegroot1996/robotframework-events
+Project-URL: Issues, https://github.com/timdegroot1996/robotframework-events/issues
+Project-URL: Changelog, https://github.com/timdegroot1996/robotframework-events/blob/main/CHANGELOG.md
+Keywords: robotframework,listener,events,jsonl,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Tool
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: jsonschema>=4.18; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Requires-Dist: mypy>=1.15; extra == "dev"
+Dynamic: license-file
+
+# robotframework-events
+
+A Robot Framework listener that writes every suite, test, keyword, control structure and log
+message of a run as JSON Lines, while the run happens. Item ids are Robot Framework's own
+(`s1-t2-k3`), so events join with `output.xml` and link into `log.html#<id>`.
+
+Requires Robot Framework 7.0 or newer and Python 3.10 or newer. Status: alpha.
+
+```
+pip install robotframework-events
+robot --listener robotframework_events.Listener tests/                       # writes ${OUTPUT DIR}/events.jsonl
+robot --listener "robotframework_events.Listener;file=ev.jsonl;level=DEBUG" tests/
+```
+
+Listener arguments: `file` (`NONE` for no file), `level` (minimum message level, default `INFO`),
+`messages`, `args`, `structures` (each `true`/`false`, default `true`) and `max_text` (default 4096).
+
+## Event format
+
+One JSON object per line. Every event has `v` (format version), `seq` (1, 2, 3, ...), `t` (Unix
+time) and `type`: `run.started`, `suite.started`, `test.started`, `step.started`,
+`message.logged`, `step.ended`, `test.ended`, `suite.ended`, `status.changed`,
+`resultfile.created`, `run.ended`.
+
+```jsonl
+{"v":1,"seq":6,"t":1791581563.542,"type":"test.started","id":"s1-t1","parent":"s1","name":"Passing","longname":"Sample.Passing","lineno":6}
+{"v":1,"seq":61,"t":1791581563.601,"type":"test.ended","id":"s1-t2","status":"FAIL","message":"1 != 2","elapsed":0.004}
+```
+
+The JSON Schema [`events-v1.schema.json`](src/robotframework_events/events-v1.schema.json) is the
+reference.
+
+## Command line
+
+```
+rfevents tail -f results/events.jsonl          # follow a run in the terminal, keyword by keyword
+rfevents tail --steps 2 --level INFO events.jsonl
+rfevents convert output.xml -o events.jsonl    # events for a run recorded without the listener
+```
+
+`tail` prints suites, tests, steps down to `--steps` levels (default 1), log messages from
+`--level` (default `WARN`) and a summary. `convert` reads `output.xml` or `output.json`; steps
+then have no source or line number, which result files do not store.
+
+## Python API
+
+```python
+from robotframework_events import RunState, add_callback, convert, read_events
+
+state = RunState.from_events(read_events("events.jsonl"))  # also .jsonl.gz
+print(state.status, state.counts())
+for event in read_events("events.jsonl", follow=True):  # while the run writes it
+    ...
+
+events = list(convert("output.xml"))  # dicts, as the listener writes them
+add_callback(fn)  # in-process consumers, e.g. robotcode's debugger
+```
+
+`read_events` gives typed events (`robotframework_events.events`). `RunState` holds the tree of
+suites, tests and steps with status, messages and times, and the running test and step.
+
+## Development
+
+```
+pip install -e .[dev]
+ruff check . && ruff format --check . && mypy
+pytest                 # format, options, schema, reader, CLI and conformance tests
+pytest -m bench        # listener overhead
+pytest -m e2e          # through robotcode's debugger (needs ../robotcode)
+```
+
+The conformance tests also run on Robot Framework's acceptance test data, found through
+`RF_ATEST_DIR` or at `../robotframework/atest/testdata`, and are skipped when it is missing.
+
+## Licence
+
+MIT

robotframework_events-0.1.0/README.md

@@ -0,0 +1,77 @@
+# robotframework-events
+
+A Robot Framework listener that writes every suite, test, keyword, control structure and log
+message of a run as JSON Lines, while the run happens. Item ids are Robot Framework's own
+(`s1-t2-k3`), so events join with `output.xml` and link into `log.html#<id>`.
+
+Requires Robot Framework 7.0 or newer and Python 3.10 or newer. Status: alpha.
+
+```
+pip install robotframework-events
+robot --listener robotframework_events.Listener tests/                       # writes ${OUTPUT DIR}/events.jsonl
+robot --listener "robotframework_events.Listener;file=ev.jsonl;level=DEBUG" tests/
+```
+
+Listener arguments: `file` (`NONE` for no file), `level` (minimum message level, default `INFO`),
+`messages`, `args`, `structures` (each `true`/`false`, default `true`) and `max_text` (default 4096).
+
+## Event format
+
+One JSON object per line. Every event has `v` (format version), `seq` (1, 2, 3, ...), `t` (Unix
+time) and `type`: `run.started`, `suite.started`, `test.started`, `step.started`,
+`message.logged`, `step.ended`, `test.ended`, `suite.ended`, `status.changed`,
+`resultfile.created`, `run.ended`.
+
+```jsonl
+{"v":1,"seq":6,"t":1791581563.542,"type":"test.started","id":"s1-t1","parent":"s1","name":"Passing","longname":"Sample.Passing","lineno":6}
+{"v":1,"seq":61,"t":1791581563.601,"type":"test.ended","id":"s1-t2","status":"FAIL","message":"1 != 2","elapsed":0.004}
+```
+
+The JSON Schema [`events-v1.schema.json`](src/robotframework_events/events-v1.schema.json) is the
+reference.
+
+## Command line
+
+```
+rfevents tail -f results/events.jsonl          # follow a run in the terminal, keyword by keyword
+rfevents tail --steps 2 --level INFO events.jsonl
+rfevents convert output.xml -o events.jsonl    # events for a run recorded without the listener
+```
+
+`tail` prints suites, tests, steps down to `--steps` levels (default 1), log messages from
+`--level` (default `WARN`) and a summary. `convert` reads `output.xml` or `output.json`; steps
+then have no source or line number, which result files do not store.
+
+## Python API
+
+```python
+from robotframework_events import RunState, add_callback, convert, read_events
+
+state = RunState.from_events(read_events("events.jsonl"))  # also .jsonl.gz
+print(state.status, state.counts())
+for event in read_events("events.jsonl", follow=True):  # while the run writes it
+    ...
+
+events = list(convert("output.xml"))  # dicts, as the listener writes them
+add_callback(fn)  # in-process consumers, e.g. robotcode's debugger
+```
+
+`read_events` gives typed events (`robotframework_events.events`). `RunState` holds the tree of
+suites, tests and steps with status, messages and times, and the running test and step.
+
+## Development
+
+```
+pip install -e .[dev]
+ruff check . && ruff format --check . && mypy
+pytest                 # format, options, schema, reader, CLI and conformance tests
+pytest -m bench        # listener overhead
+pytest -m e2e          # through robotcode's debugger (needs ../robotcode)
+```
+
+The conformance tests also run on Robot Framework's acceptance test data, found through
+`RF_ATEST_DIR` or at `../robotframework/atest/testdata`, and are skipped when it is missing.
+
+## Licence
+
+MIT

robotframework_events-0.1.0/pyproject.toml

@@ -0,0 +1,80 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "robotframework-events"
+dynamic = ["version"]
+description = "Robot Framework listener that writes execution events as JSON Lines"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Tim de Groot" }]
+requires-python = ">=3.10"
+dependencies = ["robotframework>=7.0"]
+keywords = ["robotframework", "listener", "events", "jsonl", "testing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Tool",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+
+[project.scripts]
+rfevents = "robotframework_events.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "jsonschema>=4.18", "ruff>=0.15", "mypy>=1.15"]
+
+[project.urls]
+Homepage = "https://github.com/timdegroot1996/robotframework-events"
+Issues = "https://github.com/timdegroot1996/robotframework-events/issues"
+Changelog = "https://github.com/timdegroot1996/robotframework-events/blob/main/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+version = { attr = "robotframework_events.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+robotframework_events = ["py.typed", "*.schema.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "bench: overhead benchmark (run with -m bench)",
+    "e2e: end-to-end run through robotcode's debugger (run with -m e2e)",
+]
+addopts = "-m 'not bench and not e2e'"
+filterwarnings = ["ignore::UserWarning:robot.result.modeldeprecation"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+extend-exclude = ["spike", "build", "demo"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "SIM", "RUF"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["robotframework_events", "conftest"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src"]
+strict = true
+
+[[tool.mypy.overrides]]
+module = ["robot", "robot.*"]
+follow_untyped_imports = true

robotframework_events-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

robotframework_events-0.1.0/src/robotframework_events/__init__.py

@@ -0,0 +1,30 @@
+"""Robot Framework execution events as JSON Lines.
+
+Usage::
+
+    robot --listener robotframework_events.Listener tests/
+    robot --listener robotframework_events.Listener:file=results/events.jsonl tests/
+
+Programs that run Robot Framework in the same process (for example robotcode's
+debugger) can receive every event with :func:`add_callback`. Programs that read
+events files use :func:`read_events` and :class:`RunState`.
+"""
+
+from .convert import convert
+from .events import Event, from_dict, schema
+from .listener import Listener, add_callback, remove_callback
+from .reader import read_events
+from .state import RunState
+
+__all__ = [
+    "Event",
+    "Listener",
+    "RunState",
+    "add_callback",
+    "convert",
+    "from_dict",
+    "read_events",
+    "remove_callback",
+    "schema",
+]
+__version__ = "0.1.0"

robotframework_events-0.1.0/src/robotframework_events/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

robotframework_events-0.1.0/src/robotframework_events/cli.py

@@ -0,0 +1,176 @@
+"""The ``rfevents`` command: ``tail`` shows a run in the terminal, ``convert`` builds events from a result file."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import os
+import sys
+from collections.abc import Iterable
+from typing import TextIO
+
+from . import __version__
+from .convert import convert
+from .events import (
+    Event,
+    MessageLogged,
+    RunEnded,
+    StepStarted,
+    SuiteEnded,
+    SuiteStarted,
+    TestEnded,
+    TestStarted,
+)
+from .listener import LEVELS
+from .reader import read_events
+from .state import RunState, step_label
+
+COLORS = {"PASS": "32", "FAIL": "31", "SKIP": "33", "NOT RUN": "90", "WARN": "33", "ERROR": "31"}
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="rfevents", description="Robot Framework execution events.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    tail = commands.add_parser("tail", help="show a run from its events file, readable")
+    tail.add_argument("file", help="events file (.jsonl or .jsonl.gz)")
+    tail.add_argument("-f", "--follow", action="store_true", help="wait for new events until the run ends")
+    tail.add_argument(
+        "--steps",
+        type=int,
+        default=1,
+        metavar="DEPTH",
+        help="show steps this many levels below each test, 0 for none (default 1)",
+    )
+    tail.add_argument(
+        "--level",
+        default="WARN",
+        type=str.upper,
+        choices=list(LEVELS),
+        help="show log messages from this level (default WARN)",
+    )
+    tail.add_argument("--color", choices=["auto", "always", "never"], default="auto")
+
+    conv = commands.add_parser("convert", help="build events from output.xml or output.json")
+    conv.add_argument("output", help="output.xml or output.json")
+    conv.add_argument("-o", "--outfile", help="events file to write (default: standard output)")
+
+    args = parser.parse_args(argv)
+    if isinstance(sys.stdout, io.TextIOWrapper):
+        sys.stdout.reconfigure(errors="replace")
+    try:
+        if args.command == "tail":
+            color = args.color == "always" or (
+                args.color == "auto" and sys.stdout.isatty() and "NO_COLOR" not in os.environ
+            )
+            Tail(sys.stdout, args.steps, args.level, color).show(read_events(args.file, follow=args.follow))
+        else:
+            write_converted(args.output, args.outfile)
+    except KeyboardInterrupt:
+        return 130
+    except OutputClosed:
+        # keep Python from failing again when it flushes stdout at exit
+        sys.stdout = open(os.devnull, "w")  # noqa: SIM115
+        return 0
+    except (OSError, ValueError) as e:
+        print(f"rfevents: {e}", file=sys.stderr)
+        return 2
+    return 0
+
+
+def write_converted(output: str, outfile: str | None) -> None:
+    encode = json.JSONEncoder(ensure_ascii=False, separators=(",", ":")).encode
+    lines = (encode(event) + "\n" for event in convert(output))
+    if outfile is None:
+        sys.stdout.writelines(lines)
+        return
+    with open(outfile, "w", encoding="utf-8") as file:
+        file.writelines(lines)
+
+
+class OutputClosed(Exception):
+    pass
+
+
+class Tail:
+    """Prints suites, tests, top-level steps, failures and warnings as they happen."""
+
+    def __init__(self, out: TextIO, steps: int = 1, level: str = "WARN", color: bool = False) -> None:
+        self.out = out
+        self.steps = steps
+        self.level = LEVELS[level]
+        self.color = color
+        self.state = RunState()
+
+    def show(self, events: Iterable[Event]) -> None:
+        for event in events:
+            self.state.apply(event)
+            self.print_event(event)
+
+    def print_event(self, event: Event) -> None:
+        if isinstance(event, SuiteStarted):
+            self.line(self.indent(event.id), event.longname if event.parent is None else event.name)
+        elif isinstance(event, TestStarted):
+            self.line(self.indent(event.id), event.name)
+        elif isinstance(event, StepStarted):
+            depth = self.step_depth(event.id)
+            if depth <= self.steps:
+                node = self.state.nodes[event.id]
+                kind = "" if event.kind == "KEYWORD" else ("ITER" if event.kind == "ITERATION" else event.kind)
+                parts = [kind, step_label(node), *(event.args or [])]
+                self.line(self.indent(event.id), "    ".join(p for p in parts if p))
+        elif isinstance(event, TestEnded):
+            node = self.state.nodes[event.id]
+            self.line(
+                self.indent(event.id), self.paint(node.status, node.status), node.name, f"({event.elapsed:.2f} s)"
+            )
+            if node.message:
+                self.line(self.indent(event.id) + "  ", node.message)
+        elif isinstance(event, SuiteEnded):
+            node = self.state.nodes[event.id]
+            if node.parent is not None:
+                return
+            s = event.stats
+            self.line(
+                "",
+                self.paint(node.status, node.status),
+                getattr(node.started, "longname", node.name),
+                f"{s['total']} tests, {s['passed']} passed, {s['failed']} failed, {s['skipped']} skipped",
+            )
+        elif isinstance(event, MessageLogged):
+            if LEVELS.get(event.level, 2) >= self.level and event.parent in self.state.nodes:
+                self.line(
+                    self.indent(self.shown(event.parent)) + "  ",
+                    self.paint(event.level, f"[{event.level}]"),
+                    event.text or "",
+                )
+        elif isinstance(event, RunEnded):
+            self.out.flush()
+
+    def indent(self, node_id: str | None) -> str:
+        return "  " * (len(self.state.path(node_id or "")) - 1)
+
+    def shown(self, node_id: str | None) -> str | None:
+        """The node, or its nearest ancestor that is printed."""
+        for node in reversed(self.state.path(node_id or "")):
+            if node.kind in ("SUITE", "TEST") or self.step_depth(node.id) <= self.steps:
+                return node.id
+        return node_id
+
+    def step_depth(self, node_id: str) -> int:
+        """1 for steps directly in a test or suite, 2 for their children, ..."""
+        return sum(1 for node in self.state.path(node_id) if node.kind not in ("SUITE", "TEST"))
+
+    def paint(self, status: str, text: str) -> str:
+        code = COLORS.get(status)
+        return f"\033[{code}m{text}\033[0m" if self.color and code else text
+
+    def line(self, indent: str, *parts: str) -> None:
+        self.out.write(indent + "  ".join(p for p in parts if p) + "\n")
+        self.out.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

robotframework_events-0.1.0/src/robotframework_events/convert.py

@@ -0,0 +1,172 @@
+"""Events built from an existing ``output.xml`` or ``output.json``.
+
+Gives events for runs that were recorded without the listener, so they can be replayed.
+What the result file does not store is left out: steps have no ``source`` and ``lineno``,
+``run.started`` has no ``pid`` and ``cwd``, and children of ``robot:flatten`` keywords are
+missing, as in ``log.html``. Statuses are final, so there are no ``status.changed`` events.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import uuid
+from collections.abc import Iterator
+from datetime import datetime
+from typing import Any
+
+from robot.api import ExecutionResult
+from robot.result import TestCase, TestSuite
+
+from .events import FORMAT_VERSION
+from .listener import ROOT_TYPES, _stats, step_fields
+
+GENERATOR = re.compile(r"Robot (\S+) \(\w+ (\S+)")
+
+
+def convert(path: str | os.PathLike[str], *, run: str | None = None, max_text: int = 4096) -> Iterator[dict[str, Any]]:
+    """Yields the events of a result file as dicts, in the order a live run emits them."""
+    result = ExecutionResult(str(path))
+    return _Converter(max_text).events(result, str(path), run or str(uuid.uuid4()))
+
+
+def _time(value: datetime | None) -> float | None:
+    return round(value.timestamp(), 3) if value else None
+
+
+class _Counter:
+    __slots__ = ("children", "id")
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+        self.children = 0
+
+
+class _Converter:
+    def __init__(self, max_text: int) -> None:
+        self.max_text = max_text
+        self.seq = 0
+        self.t = 0.0
+
+    def emit(self, type_: str, t: float | None, **fields: Any) -> dict[str, Any]:
+        self.seq += 1
+        # NOT RUN items have no times; keep time moving forward
+        self.t = max(self.t, t) if t is not None else self.t
+        event: dict[str, Any] = {"v": FORMAT_VERSION, "seq": self.seq, "t": self.t, "type": type_}
+        event.update((k, v) for k, v in fields.items() if v is not None and v != "")
+        return event
+
+    def events(self, result: Any, path: str, run: str) -> Iterator[dict[str, Any]]:
+        suite = result.suite
+        match = GENERATOR.match(getattr(result, "generator", "") or "")
+        self.t = _time(suite.start_time) or 0.0
+        yield self.emit(
+            "run.started",
+            self.t,
+            run=run,
+            rf=match.group(1) if match else "unknown",
+            python=match.group(2) if match else None,
+        )
+        yield from self.suite(suite, "s1", None)
+        yield self.emit("resultfile.created", None, kind="OUTPUT", path=path)
+        yield self.emit("run.ended", None, status=suite.status, stats=_stats(suite))
+
+    def suite(self, suite: TestSuite, id: str, parent: str | None) -> Iterator[dict[str, Any]]:
+        yield self.emit(
+            "suite.started",
+            _time(suite.start_time),
+            id=id,
+            parent=parent,
+            name=suite.name,
+            longname=suite.full_name,
+            source=str(suite.source) if suite.source else None,
+            tests=suite.test_count,
+        )
+        counter = _Counter(id)
+        if suite.has_setup:
+            yield from self.step(suite.setup, counter, id)
+        for index, child in enumerate(suite.suites, 1):
+            yield from self.suite(child, f"{id}-s{index}", id)
+        for index, test in enumerate(suite.tests, 1):
+            yield from self.test(test, f"{id}-t{index}", id)
+        if suite.has_teardown:
+            yield from self.step(suite.teardown, counter, id)
+        yield self.emit(
+            "suite.ended",
+            _time(suite.end_time),
+            id=id,
+            status=suite.status,
+            message=suite.message,
+            elapsed=round(suite.elapsed_time.total_seconds(), 3),
+            stats=_stats(suite),
+        )
+
+    def test(self, test: TestCase, id: str, parent: str) -> Iterator[dict[str, Any]]:
+        yield self.emit(
+            "test.started",
+            _time(test.start_time),
+            id=id,
+            parent=parent,
+            name=test.name,
+            longname=test.full_name,
+            source=str(test.source) if test.source else None,
+            lineno=test.lineno,
+            tags=list(test.tags) or None,
+        )
+        counter = _Counter(id)
+        if test.has_setup:
+            yield from self.step(test.setup, counter, id)
+        yield from self.body(test.body, counter, id)
+        if test.has_teardown:
+            yield from self.step(test.teardown, counter, id)
+        yield self.emit(
+            "test.ended",
+            _time(test.end_time),
+            id=id,
+            status=test.status,
+            message=test.message,
+            elapsed=round(test.elapsed_time.total_seconds(), 3),
+        )
+
+    def body(self, items: Any, counter: _Counter, parent: str) -> Iterator[dict[str, Any]]:
+        for item in items:
+            if item.type == "MESSAGE":
+                text = item.message or ""
+                truncated = len(text) > self.max_text
+                yield self.emit(
+                    "message.logged",
+                    _time(item.timestamp),
+                    parent=parent,
+                    level=item.level,
+                    text=text[: self.max_text] if truncated else text,
+                    truncated=True if truncated else None,
+                    html=True if item.html else None,
+                )
+            elif item.type in ROOT_TYPES:
+                # IF/TRY branches are numbered as children of the root's parent
+                yield from self.body(item.body, counter, parent)
+            else:
+                yield from self.step(item, counter, parent)
+
+    def step(self, item: Any, counter: _Counter, parent: str) -> Iterator[dict[str, Any]]:
+        counter.children += 1
+        id = f"{counter.id}-k{counter.children}"
+        kind = item.type
+        yield self.emit(
+            "step.started", _time(item.start_time), id=id, parent=parent, kind=kind, **step_fields(kind, item)
+        )
+        own = _Counter(id)
+        if getattr(item, "has_setup", False):
+            yield from self.step(item.setup, own, id)
+        if hasattr(item, "body"):
+            yield from self.body(item.body, own, id)
+        if getattr(item, "has_teardown", False):
+            yield from self.step(item.teardown, own, id)
+        yield self.emit(
+            "step.ended",
+            _time(item.end_time),
+            id=id,
+            status=item.status,
+            message=item.message,
+            elapsed=round(item.elapsed_time.total_seconds(), 4),
+        )