spark-advisor-parser 0.1.14__tar.gz

spark_advisor_parser-0.1.14/.gitignore

@@ -0,0 +1,42 @@
+**/CLAUDE.md
+.claude/
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+build/
+
+# Virtual environment
+.venv/
+.envrc
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+
+# Type checking
+.mypy_cache/
+
+# Ruff
+.ruff_cache/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+/.claude/
+tasks
+
+# Frontend
+node_modules/
+packages/spark-advisor-frontend/dist/

spark_advisor_parser-0.1.14/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: spark-advisor-parser
+Version: 0.1.14
+Summary: Spark event log parser with compression support (.gz, .lz4, .snappy, .zstd)
+Project-URL: Homepage, https://github.com/pstysz/spark-advisor
+Project-URL: Repository, https://github.com/pstysz/spark-advisor
+Author: Pawel Stysz
+License-Expression: Apache-2.0
+Keywords: apache-spark,event-log,parser,spark
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: lz4>=4.0
+Requires-Dist: orjson>=3.10
+Requires-Dist: python-snappy>=0.7
+Requires-Dist: spark-advisor-models==0.1.14
+Requires-Dist: zstandard>=0.23
+Description-Content-Type: text/plain
+
+Spark event log parser with compression support

spark_advisor_parser-0.1.14/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "spark-advisor-parser"
+version = "0.1.14" # x-release-please-version
+description = "Spark event log parser with compression support (.gz, .lz4, .snappy, .zstd)"
+readme = { text = "Spark event log parser with compression support", content-type = "text/plain" }
+license = "Apache-2.0"
+requires-python = ">=3.12"
+authors = [
+    { name = "Pawel Stysz" },
+]
+keywords = ["spark", "apache-spark", "event-log", "parser"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = [
+    "spark-advisor-models==0.1.14",  # x-release-please-version
+    "orjson>=3.10",
+    "lz4>=4.0",
+    "python-snappy>=0.7",
+    "zstandard>=0.23",
+]
+
+[tool.uv.sources]
+spark-advisor-models = { workspace = true }
+
+[project.urls]
+Homepage = "https://github.com/pstysz/spark-advisor"
+Repository = "https://github.com/pstysz/spark-advisor"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/spark_advisor_parser"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3",
+    "pytest-cov>=6.1",
+    "mypy>=1.15",
+    "ruff>=0.11",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--tb=short",
+]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "SIM", "TCH", "RUF"]
+
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = ["pydantic.BaseModel", "pydantic_settings.BaseSettings"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["spark_advisor_parser", "spark_advisor_models"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+plugins = ["pydantic.mypy"]

spark_advisor_parser-0.1.14/src/spark_advisor_parser/__init__.py

@@ -0,0 +1,3 @@
+from spark_advisor_parser.parser import parse_event_log
+
+__all__ = ["parse_event_log"]

spark_advisor_parser-0.1.14/src/spark_advisor_parser/parser.py

@@ -0,0 +1,274 @@
+import gzip
+import io
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import IO, Any
+
+import lz4.frame  # type: ignore[import-untyped]
+import orjson
+import snappy  # type: ignore[import-untyped]
+import zstandard
+
+from spark_advisor_models.model import (
+    ExecutorMetrics,
+    JobAnalysis,
+    Quantiles,
+    SparkConfig,
+    StageMetrics,
+    TaskMetrics,
+    TaskMetricsDistributions,
+)
+
+
+def parse_event_log(path: Path) -> JobAnalysis:
+    state = _ParserState()
+
+    with _open_event_log(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                event = orjson.loads(line)
+            except orjson.JSONDecodeError:
+                continue
+            _process_event(event, state)
+
+    return state.build()
+
+
+@contextmanager
+def _open_event_log(path: Path) -> Iterator[IO[str]]:
+    suffix = path.suffix.lower()
+    suffixes = [s.lower() for s in path.suffixes]
+
+    if suffix == ".gz" or ".gz" in suffixes:
+        with gzip.open(path, "rt", encoding="utf-8") as f:
+            yield f
+    elif suffix == ".lz4":
+        with lz4.frame.open(path, "rt", encoding="utf-8") as f:
+            yield f
+    elif suffix == ".snappy":
+        raw = path.read_bytes()
+        decompressed = snappy.decompress(raw)
+        yield io.StringIO(decompressed.decode("utf-8"))
+    elif suffix == ".zstd" or suffix == ".zst":
+        dctx = zstandard.ZstdDecompressor()
+        with open(path, "rb") as raw_f, dctx.stream_reader(raw_f) as reader:
+            yield io.TextIOWrapper(reader, encoding="utf-8")
+    else:
+        with open(path, encoding="utf-8") as f:
+            yield f
+
+
+def _quantiles_from_list(values: list[int]) -> Quantiles:
+    if not values:
+        return Quantiles()
+    s = sorted(values)
+    n = len(s)
+
+    def _percentile(p: float) -> int:
+        idx = p * (n - 1)
+        lo = int(idx)
+        hi = min(lo + 1, n - 1)
+        frac = idx - lo
+        return int(s[lo] + frac * (s[hi] - s[lo]))
+
+    return Quantiles(
+        min=s[0],
+        p25=_percentile(0.25),
+        median=_percentile(0.5),
+        p75=_percentile(0.75),
+        max=s[-1],
+    )
+
+
+@dataclass
+class _StageAccumulator:
+    durations: list[int] = field(default_factory=list)
+    executor_run_times: list[int] = field(default_factory=list)
+    gc_times: list[int] = field(default_factory=list)
+    task_count: int = 0
+    total_gc_time_ms: int = 0
+    total_executor_run_time_ms: int = 0
+    shuffle_read_bytes: int = 0
+    shuffle_write_bytes: int = 0
+    spill_disk_bytes: int = 0
+    spill_memory_bytes: int = 0
+    failed_count: int = 0
+    killed_count: int = 0
+    input_records: int = 0
+    output_records: int = 0
+    shuffle_read_records: int = 0
+    shuffle_write_records: int = 0
+
+    def add_task(self, task_info: dict[str, Any], task_metrics: dict[str, Any], event: dict[str, Any]) -> None:
+        if task_info.get("Failed", False):
+            self.failed_count += 1
+
+        task_end_reason = event.get("Task End Reason", {})
+        if task_end_reason.get("Reason") == "TaskKilled":
+            self.killed_count += 1
+
+        duration = task_info.get("Finish Time", 0) - task_info.get("Launch Time", 0)
+        self.durations.append(duration)
+        self.task_count += 1
+
+        gc_time = task_metrics.get("JVM GC Time", 0)
+        self.gc_times.append(gc_time)
+        self.total_gc_time_ms += gc_time
+
+        executor_run_time = task_metrics.get("Executor Run Time", 0)
+        self.executor_run_times.append(executor_run_time)
+        self.total_executor_run_time_ms += executor_run_time
+
+        shuffle_read = task_metrics.get("Shuffle Read Metrics", {})
+        self.shuffle_read_bytes += shuffle_read.get("Remote Bytes Read", 0)
+        self.shuffle_read_bytes += shuffle_read.get("Local Bytes Read", 0)
+        self.shuffle_read_records += shuffle_read.get("Total Records Read", 0)
+
+        shuffle_write = task_metrics.get("Shuffle Write Metrics", {})
+        self.shuffle_write_bytes += shuffle_write.get("Shuffle Bytes Written", 0)
+        self.shuffle_write_records += shuffle_write.get("Shuffle Records Written", 0)
+
+        input_m = task_metrics.get("Input Metrics", {})
+        self.input_records += input_m.get("Records Read", 0)
+
+        output_m = task_metrics.get("Output Metrics", {})
+        self.output_records += output_m.get("Records Written", 0)
+
+        self.spill_disk_bytes += task_metrics.get("Disk Bytes Spilled", 0)
+        self.spill_memory_bytes += task_metrics.get("Memory Bytes Spilled", 0)
+
+    def build_stage_metrics(self, stage_id: int, stage_info: dict[str, Any]) -> StageMetrics:
+        distributions = TaskMetricsDistributions(
+            duration=_quantiles_from_list(self.durations),
+            executor_run_time=_quantiles_from_list(self.executor_run_times),
+            jvm_gc_time=_quantiles_from_list(self.gc_times),
+        )
+        return StageMetrics(
+            stage_id=stage_id,
+            stage_name=stage_info.get("name", f"Stage {stage_id}"),
+            sum_executor_run_time_ms=self.total_executor_run_time_ms,
+            total_gc_time_ms=self.total_gc_time_ms,
+            total_shuffle_read_bytes=self.shuffle_read_bytes,
+            total_shuffle_write_bytes=self.shuffle_write_bytes,
+            spill_to_disk_bytes=self.spill_disk_bytes,
+            spill_to_memory_bytes=self.spill_memory_bytes,
+            failed_task_count=self.failed_count,
+            killed_task_count=self.killed_count,
+            input_bytes=stage_info.get("input_bytes", 0),
+            input_records=self.input_records,
+            output_bytes=stage_info.get("output_bytes", 0),
+            output_records=self.output_records,
+            shuffle_read_records=self.shuffle_read_records,
+            shuffle_write_records=self.shuffle_write_records,
+            tasks=TaskMetrics(
+                task_count=self.task_count,
+                distributions=distributions,
+            ),
+        )
+
+
+class _ParserState:
+    def __init__(self) -> None:
+        self.app_id: str = ""
+        self.app_name: str = ""
+        self.spark_version: str = ""
+        self.start_time: int = 0
+        self.end_time: int = 0
+        self.config: dict[str, str] = {}
+        self.stage_info: dict[int, dict[str, Any]] = {}
+        self.stage_tasks: dict[int, _StageAccumulator] = defaultdict(_StageAccumulator)
+        self.executor_count: int = 0
+
+    def _resolve_end_time(self) -> int:
+        if self.end_time > self.start_time:
+            return self.end_time
+        if self.stage_info:
+            return max(
+                (info.get("completion_time", 0) for info in self.stage_info.values()),
+                default=self.start_time,
+            )
+        return self.start_time
+
+    def build(self) -> JobAnalysis:
+        end_time = self._resolve_end_time()
+
+        stages = []
+        for stage_id, info in sorted(self.stage_info.items()):
+            acc = self.stage_tasks[stage_id]
+            stages.append(acc.build_stage_metrics(stage_id, info))
+
+        total_task_time = sum(acc.total_executor_run_time_ms for acc in self.stage_tasks.values())
+
+        return JobAnalysis(
+            app_id=self.app_id,
+            app_name=self.app_name,
+            spark_version=self.spark_version,
+            duration_ms=end_time - self.start_time,
+            config=SparkConfig(raw=self.config),
+            stages=stages,
+            executors=ExecutorMetrics(
+                executor_count=self.executor_count,
+                peak_memory_bytes_sum=0,
+                allocated_memory_bytes_sum=0,
+                total_task_time_ms=total_task_time,
+            ),
+        )
+
+
+def _process_event(event: dict[str, Any], state: _ParserState) -> None:
+    event_type = event.get("Event", "")
+
+    match event_type:
+        case "SparkListenerApplicationStart":
+            state.app_id = event.get("App ID", "")
+            state.app_name = event.get("App Name", "")
+            state.start_time = event.get("Timestamp", 0)
+
+        case "SparkListenerApplicationEnd":
+            state.end_time = event.get("Timestamp", 0)
+
+        case "SparkListenerLogStart":
+            state.spark_version = event.get("Spark Version", "")
+
+        case "SparkListenerEnvironmentUpdate":
+            for key, value in event.get("Spark Properties", {}).items():
+                state.config[key] = value
+
+        case "SparkListenerStageCompleted":
+            stage_info = event.get("Stage Info", {})
+            stage_id = stage_info.get("Stage ID", -1)
+            state.stage_info[stage_id] = {
+                "name": stage_info.get("Stage Name", ""),
+                "submission_time": stage_info.get("Submission Time", 0),
+                "completion_time": stage_info.get("Completion Time", 0),
+                "input_bytes": _extract_accumulator(stage_info, "internal.metrics.input.bytesRead"),
+                "output_bytes": _extract_accumulator(stage_info, "internal.metrics.output.bytesWritten")
+                if stage_info.get("Accumulables")
+                else 0,
+            }
+
+        case "SparkListenerTaskEnd":
+            stage_id = event.get("Stage ID", -1)
+            task_info = event.get("Task Info", {})
+            task_metrics = event.get("Task Metrics", {})
+
+            if not task_info or not task_metrics:
+                return
+
+            state.stage_tasks[stage_id].add_task(task_info, task_metrics, event)
+
+        case "SparkListenerExecutorAdded":
+            state.executor_count += 1
+
+
+def _extract_accumulator(stage_info: dict[str, Any], name: str) -> int:
+    for acc in stage_info.get("Accumulables", []):
+        if acc.get("Name") == name:
+            return int(acc.get("Value", 0))
+    return 0

spark_advisor_parser-0.1.14/tests/test_parser.py

@@ -0,0 +1,266 @@
+import gzip
+import json
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import lz4.frame
+import snappy
+import zstandard
+
+from spark_advisor_parser import parse_event_log
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+SAMPLE_LOG = _REPO_ROOT / "sample_event_logs" / "sample_etl_job.json"
+
+
+def _write_events(events: list[dict[str, Any]]) -> Path:
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+        for e in events:
+            f.write(json.dumps(e) + "\n")
+    return Path(f.name)
+
+
+def _events_as_bytes(events: list[dict[str, Any]]) -> bytes:
+    return "\n".join(json.dumps(e) for e in events).encode("utf-8")
+
+
+def _base_events() -> list[dict[str, Any]]:
+    return [
+        {"Event": "SparkListenerLogStart", "Spark Version": "3.5.0"},
+        {
+            "Event": "SparkListenerApplicationStart",
+            "App ID": "app-1",
+            "App Name": "Test",
+            "Timestamp": 1000,
+        },
+        {
+            "Event": "SparkListenerEnvironmentUpdate",
+            "Spark Properties": {"spark.executor.memory": "4g"},
+        },
+        {
+            "Event": "SparkListenerStageCompleted",
+            "Stage Info": {"Stage ID": 0, "Stage Name": "read", "Accumulables": []},
+        },
+    ]
+
+
+def _task_event(stage_id: int = 0, **metric_overrides: Any) -> dict[str, Any]:
+    metrics: dict[str, Any] = {
+        "Executor Run Time": 900,
+        "JVM GC Time": 10,
+        "Shuffle Read Metrics": {"Remote Bytes Read": 0},
+        "Shuffle Write Metrics": {"Shuffle Bytes Written": 0},
+        "Disk Bytes Spilled": 0,
+        "Memory Bytes Spilled": 0,
+    }
+    metrics.update(metric_overrides)
+    event: dict[str, Any] = {
+        "Event": "SparkListenerTaskEnd",
+        "Stage ID": stage_id,
+        "Task Info": {"Launch Time": 1000, "Finish Time": 2000, "Failed": False},
+        "Task Metrics": metrics,
+    }
+    return event
+
+
+_APP_END: dict[str, Any] = {"Event": "SparkListenerApplicationEnd", "Timestamp": 5000}
+
+
+class TestParseEventLog:
+    def test_parses_app_metadata(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        assert job.app_id == "application_1234567890_0001"
+        assert job.app_name == "SampleETLJob"
+
+    def test_parses_config(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        assert job.config.executor_memory == "4g"
+        assert job.config.shuffle_partitions == 200
+        assert job.config.aqe_enabled is False
+
+    def test_parses_stages(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        assert len(job.stages) == 2
+
+    def test_aggregates_task_metrics(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        stage1 = next(s for s in job.stages if s.stage_id == 1)
+        assert stage1.tasks.task_count == 3
+        assert stage1.spill_to_disk_bytes > 0
+
+    def test_detects_skew_in_sample(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        stage1 = next(s for s in job.stages if s.stage_id == 1)
+        assert stage1.tasks.duration_skew_ratio > 10
+
+    def test_calculates_duration(self) -> None:
+        job = parse_event_log(SAMPLE_LOG)
+        assert job.duration_ms > 0
+
+
+class TestEventParserRecords:
+    def test_collects_input_and_output_records(self) -> None:
+        task = _task_event(
+            **{
+                "Input Metrics": {"Bytes Read": 1024, "Records Read": 500},
+                "Output Metrics": {"Bytes Written": 512, "Records Written": 250},
+            },
+        )
+        events = [*_base_events(), task, _APP_END]
+        job = parse_event_log(_write_events(events))
+        stage = job.stages[0]
+        assert stage.input_records == 500
+        assert stage.output_records == 250
+
+    def test_collects_shuffle_records(self) -> None:
+        task = _task_event(
+            **{
+                "Shuffle Read Metrics": {
+                    "Remote Bytes Read": 100,
+                    "Local Bytes Read": 200,
+                    "Total Records Read": 1000,
+                },
+                "Shuffle Write Metrics": {
+                    "Shuffle Bytes Written": 300,
+                    "Shuffle Records Written": 800,
+                },
+            },
+        )
+        events = [*_base_events(), task, _APP_END]
+        job = parse_event_log(_write_events(events))
+        stage = job.stages[0]
+        assert stage.total_shuffle_read_bytes == 300
+        assert stage.shuffle_read_records == 1000
+        assert stage.shuffle_write_records == 800
+
+    def test_counts_killed_tasks(self) -> None:
+        task = _task_event()
+        task["Task End Reason"] = {"Reason": "TaskKilled"}
+        events = [*_base_events(), task, _APP_END]
+        job = parse_event_log(_write_events(events))
+        stage = job.stages[0]
+        assert stage.killed_task_count == 1
+
+    def test_local_shuffle_read_included(self) -> None:
+        task = _task_event(
+            **{
+                "Shuffle Read Metrics": {
+                    "Remote Bytes Read": 500,
+                    "Local Bytes Read": 300,
+                },
+            },
+        )
+        events = [*_base_events(), task, _APP_END]
+        job = parse_event_log(_write_events(events))
+        stage = job.stages[0]
+        assert stage.total_shuffle_read_bytes == 800
+
+
+class TestMalformedLines:
+    def test_skips_malformed_json(self) -> None:
+        path = _write_events(_base_events())
+        with open(path, "a") as f:
+            f.write("this is not json\n")
+            f.write(json.dumps(_APP_END) + "\n")
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+
+    def test_skips_empty_lines(self) -> None:
+        path = _write_events(_base_events())
+        with open(path, "a") as f:
+            f.write("\n\n\n")
+            f.write(json.dumps(_APP_END) + "\n")
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+
+
+class TestIncompleteLogs:
+    def test_missing_app_end_uses_stage_completion_time(self) -> None:
+        events = [
+            {"Event": "SparkListenerApplicationStart", "App ID": "app-1", "App Name": "Test", "Timestamp": 1000},
+            {
+                "Event": "SparkListenerStageCompleted",
+                "Stage Info": {
+                    "Stage ID": 0,
+                    "Stage Name": "read",
+                    "Completion Time": 4000,
+                    "Accumulables": [],
+                },
+            },
+            _task_event(),
+        ]
+        job = parse_event_log(_write_events(events))
+        assert job.duration_ms == 3000
+
+    def test_missing_app_end_no_stages(self) -> None:
+        events = [
+            {"Event": "SparkListenerApplicationStart", "App ID": "app-1", "App Name": "Test", "Timestamp": 1000},
+        ]
+        job = parse_event_log(_write_events(events))
+        assert job.duration_ms == 0
+
+
+class TestGzipSupport:
+    def test_parses_gzipped_event_log(self) -> None:
+        events = [*_base_events(), _task_event(), _APP_END]
+        with tempfile.NamedTemporaryFile(suffix=".json.gz", delete=False) as f:
+            with gzip.open(f.name, "wt", encoding="utf-8") as gz:
+                for e in events:
+                    gz.write(json.dumps(e) + "\n")
+            path = Path(f.name)
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+        assert len(job.stages) == 1
+
+
+class TestLz4Support:
+    def test_parses_lz4_event_log(self) -> None:
+        events = [*_base_events(), _task_event(), _APP_END]
+        data = _events_as_bytes(events)
+        with tempfile.NamedTemporaryFile(suffix=".lz4", delete=False) as f:
+            with lz4.frame.open(f.name, "wb") as lz4f:
+                lz4f.write(data)
+            path = Path(f.name)
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+        assert len(job.stages) == 1
+
+
+class TestSnappySupport:
+    def test_parses_snappy_event_log(self) -> None:
+        events = [*_base_events(), _task_event(), _APP_END]
+        data = _events_as_bytes(events)
+        compressed = snappy.compress(data)
+        with tempfile.NamedTemporaryFile(suffix=".snappy", delete=False) as f:
+            f.write(compressed)
+            path = Path(f.name)
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+        assert len(job.stages) == 1
+
+
+class TestZstdSupport:
+    def test_parses_zstd_event_log(self) -> None:
+        events = [*_base_events(), _task_event(), _APP_END]
+        data = _events_as_bytes(events)
+        cctx = zstandard.ZstdCompressor()
+        compressed = cctx.compress(data)
+        with tempfile.NamedTemporaryFile(suffix=".zstd", delete=False) as f:
+            f.write(compressed)
+            path = Path(f.name)
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+        assert len(job.stages) == 1
+
+    def test_parses_zst_extension(self) -> None:
+        events = [*_base_events(), _task_event(), _APP_END]
+        data = _events_as_bytes(events)
+        cctx = zstandard.ZstdCompressor()
+        compressed = cctx.compress(data)
+        with tempfile.NamedTemporaryFile(suffix=".zst", delete=False) as f:
+            f.write(compressed)
+            path = Path(f.name)
+        job = parse_event_log(path)
+        assert job.app_id == "app-1"
+        assert len(job.stages) == 1