statusdoc 0.1.0__tar.gz

statusdoc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrea Acanfora
+
+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.

statusdoc-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: statusdoc
+Version: 0.1.0
+Summary: Open Status Document: a spec and tools to discover, read and validate service status pages
+Author: Andrea Acanfora
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AndreaAcanfora/statusdoc
+Project-URL: Specification, https://github.com/AndreaAcanfora/statusdoc/blob/master/SPEC.md
+Keywords: status page,statuspage,incidents,monitoring,sre,uptime
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# statusdoc: Open Status Document
+
+[![CI](https://github.com/AndreaAcanfora/statusdoc/actions/workflows/ci.yml/badge.svg)](https://github.com/AndreaAcanfora/statusdoc/actions/workflows/ci.yml)
+
+A specification and a Python tool to **find, read and validate the status
+pages of the services you depend on**, starting from nothing but their
+domain.
+
+![statusdoc check: GitHub, Anthropic, Stripe, Slack and Vercel operational; Cloudflare with a partial outage and its incidents](docs/demo.png)
+
+- **Specification:** [SPEC.md](SPEC.md), Open Status Document (OSD) 0.1, draft.
+- **Compatible with what is deployed:** OSD specifies the `summary.json`
+  shape that Atlassian Statuspage made common and other providers mirror, so
+  thousands of status pages already serve conforming documents.
+- **Adds discovery:** `https://{domain}/.well-known/status` tells programs
+  where a service's status document lives.
+- **Zero dependencies**, Python 3.10+.
+
+## Why
+
+Status pages are for people. Programs need the same information: a CI
+pipeline that should hold a deploy while the cloud provider has an outage, a
+dashboard of upstream dependencies, a support bot that explains an error.
+Today that means knowing that GitHub's status lives on `githubstatus.com`
+and Stripe's on `stripestatus.com`, and writing a parser for every format.
+Commercial aggregators maintain thousands of such scrapers.
+
+OSD turns the de facto format into a written spec, and lets each service
+announce its document on its own domain.
+
+## Install
+
+```sh
+pip install git+https://github.com/AndreaAcanfora/statusdoc
+```
+
+## Command line
+
+```sh
+statusdoc check github.com npmjs.com             # exit 1 if any is degraded
+statusdoc check --fail-on major vercel.com       # only major and critical fail
+statusdoc check --json -v github.com             # machine-readable, with components
+statusdoc discover fly.io                        # where is the status document?
+statusdoc validate status.example.com            # is it conforming?
+statusdoc convert status.betterstack.com         # any supported format → OSD JSON
+```
+
+Targets are domains (`github.com`), status page URLs or document URLs.
+Exit codes of `check`: `0` all fine, `1` at least one service at or above
+`--fail-on` (default `minor`), `3` a service could not be reached.
+
+### GitHub Action: hold a deploy during an upstream outage
+
+```yaml
+- uses: AndreaAcanfora/statusdoc@v0
+  with:
+    services: github.com npmjs.com vercel.com
+    fail-on: major          # minor, major, critical or never
+```
+
+The step fails when a service is at or above `fail-on`, adds a table to the
+job summary and annotations to the run, and sets the outputs `worst-level`,
+`degraded`, `unreachable` and `report` (JSON) for later steps. A status page
+that cannot be read only produces a warning, unless
+`fail-on-unreachable: true`. It runs on Linux, macOS and Windows runners with
+any Python 3.10+, and installs nothing.
+
+Or from any CI:
+
+```sh
+pip install git+https://github.com/AndreaAcanfora/statusdoc
+statusdoc check --fail-on major github.com npmjs.com vercel.com
+```
+
+## How documents are found
+
+1. `https://{domain}/.well-known/status`, the discovery URI defined by OSD.
+2. A list of known services bundled with the tool (60 services, each verified
+   by hand), checked weekly by CI.
+3. Conventions: `status.{domain}`, `{name}status.com`, `www.{name}status.com`,
+   at `/api/v2/summary.json` (Statuspage shape) or `/index.json` (Better Stack).
+
+Better Stack pages and the Slack Status API are converted to OSD on the fly.
+Other formats can be added as adapters.
+
+## Library
+
+```python
+from statusdoc import discover, validate_document
+
+found = discover("github.com")
+doc = found.document
+print(doc.name, doc.level)  # GitHub operational
+for incident in doc.open_incidents:
+    print(incident.name, incident.impact, incident.shortlink)
+for c in doc.components:
+    if c.status != "operational":
+        print(c.name, c.status)
+
+issues = validate_document(found.response.json())
+```
+
+`doc.level` is one of `operational`, `maintenance`, `minor`, `major`,
+`critical`: the publisher's indicator, raised by open incidents and active
+maintenance.
+
+## Publishing a conforming status page
+
+If your status page runs on Statuspage or a compatible provider, it most
+likely conforms already. Two small additions complete it:
+
+1. **Announce it on your own domain.** Serve this at
+   `https://example.com/.well-known/status`, with
+   `Content-Type: application/json` and `Access-Control-Allow-Origin: *`:
+
+   ```json
+   {
+     "osd_version": "0.1",
+     "document": "https://status.example.com/api/v2/summary.json",
+     "page": "https://status.example.com"
+   }
+   ```
+
+   With nginx:
+
+   ```nginx
+   location = /.well-known/status {
+       default_type application/json;
+       add_header Access-Control-Allow-Origin *;
+       return 200 '{"osd_version":"0.1","document":"https://status.example.com/api/v2/summary.json","page":"https://status.example.com"}';
+   }
+   ```
+
+2. **Run the validator:** `statusdoc validate example.com`.
+
+If you build your own status page, `Document.to_dict()` produces a
+conforming document, and SPEC.md lists every field.
+
+## Status
+
+The spec is a 0.1 draft. The most useful contributions right now are
+feedback on the spec, new verified entries for the service list and adapters
+for other status page providers.
+
+## Related work
+
+- Atlassian Statuspage's public API, whose `summary.json` shape OSD specifies.
+- The expired IETF draft *Service Status Resource Format for Web Services*,
+  which proposed a new format instead.
+- Aggregators such as StatusGator (commercial) and Statusphere (open source),
+  which scrape status pages with one parser per provider.
+
+## License
+
+MIT

statusdoc-0.1.0/README.md

@@ -0,0 +1,155 @@
+# statusdoc: Open Status Document
+
+[![CI](https://github.com/AndreaAcanfora/statusdoc/actions/workflows/ci.yml/badge.svg)](https://github.com/AndreaAcanfora/statusdoc/actions/workflows/ci.yml)
+
+A specification and a Python tool to **find, read and validate the status
+pages of the services you depend on**, starting from nothing but their
+domain.
+
+![statusdoc check: GitHub, Anthropic, Stripe, Slack and Vercel operational; Cloudflare with a partial outage and its incidents](docs/demo.png)
+
+- **Specification:** [SPEC.md](SPEC.md), Open Status Document (OSD) 0.1, draft.
+- **Compatible with what is deployed:** OSD specifies the `summary.json`
+  shape that Atlassian Statuspage made common and other providers mirror, so
+  thousands of status pages already serve conforming documents.
+- **Adds discovery:** `https://{domain}/.well-known/status` tells programs
+  where a service's status document lives.
+- **Zero dependencies**, Python 3.10+.
+
+## Why
+
+Status pages are for people. Programs need the same information: a CI
+pipeline that should hold a deploy while the cloud provider has an outage, a
+dashboard of upstream dependencies, a support bot that explains an error.
+Today that means knowing that GitHub's status lives on `githubstatus.com`
+and Stripe's on `stripestatus.com`, and writing a parser for every format.
+Commercial aggregators maintain thousands of such scrapers.
+
+OSD turns the de facto format into a written spec, and lets each service
+announce its document on its own domain.
+
+## Install
+
+```sh
+pip install git+https://github.com/AndreaAcanfora/statusdoc
+```
+
+## Command line
+
+```sh
+statusdoc check github.com npmjs.com             # exit 1 if any is degraded
+statusdoc check --fail-on major vercel.com       # only major and critical fail
+statusdoc check --json -v github.com             # machine-readable, with components
+statusdoc discover fly.io                        # where is the status document?
+statusdoc validate status.example.com            # is it conforming?
+statusdoc convert status.betterstack.com         # any supported format → OSD JSON
+```
+
+Targets are domains (`github.com`), status page URLs or document URLs.
+Exit codes of `check`: `0` all fine, `1` at least one service at or above
+`--fail-on` (default `minor`), `3` a service could not be reached.
+
+### GitHub Action: hold a deploy during an upstream outage
+
+```yaml
+- uses: AndreaAcanfora/statusdoc@v0
+  with:
+    services: github.com npmjs.com vercel.com
+    fail-on: major          # minor, major, critical or never
+```
+
+The step fails when a service is at or above `fail-on`, adds a table to the
+job summary and annotations to the run, and sets the outputs `worst-level`,
+`degraded`, `unreachable` and `report` (JSON) for later steps. A status page
+that cannot be read only produces a warning, unless
+`fail-on-unreachable: true`. It runs on Linux, macOS and Windows runners with
+any Python 3.10+, and installs nothing.
+
+Or from any CI:
+
+```sh
+pip install git+https://github.com/AndreaAcanfora/statusdoc
+statusdoc check --fail-on major github.com npmjs.com vercel.com
+```
+
+## How documents are found
+
+1. `https://{domain}/.well-known/status`, the discovery URI defined by OSD.
+2. A list of known services bundled with the tool (60 services, each verified
+   by hand), checked weekly by CI.
+3. Conventions: `status.{domain}`, `{name}status.com`, `www.{name}status.com`,
+   at `/api/v2/summary.json` (Statuspage shape) or `/index.json` (Better Stack).
+
+Better Stack pages and the Slack Status API are converted to OSD on the fly.
+Other formats can be added as adapters.
+
+## Library
+
+```python
+from statusdoc import discover, validate_document
+
+found = discover("github.com")
+doc = found.document
+print(doc.name, doc.level)  # GitHub operational
+for incident in doc.open_incidents:
+    print(incident.name, incident.impact, incident.shortlink)
+for c in doc.components:
+    if c.status != "operational":
+        print(c.name, c.status)
+
+issues = validate_document(found.response.json())
+```
+
+`doc.level` is one of `operational`, `maintenance`, `minor`, `major`,
+`critical`: the publisher's indicator, raised by open incidents and active
+maintenance.
+
+## Publishing a conforming status page
+
+If your status page runs on Statuspage or a compatible provider, it most
+likely conforms already. Two small additions complete it:
+
+1. **Announce it on your own domain.** Serve this at
+   `https://example.com/.well-known/status`, with
+   `Content-Type: application/json` and `Access-Control-Allow-Origin: *`:
+
+   ```json
+   {
+     "osd_version": "0.1",
+     "document": "https://status.example.com/api/v2/summary.json",
+     "page": "https://status.example.com"
+   }
+   ```
+
+   With nginx:
+
+   ```nginx
+   location = /.well-known/status {
+       default_type application/json;
+       add_header Access-Control-Allow-Origin *;
+       return 200 '{"osd_version":"0.1","document":"https://status.example.com/api/v2/summary.json","page":"https://status.example.com"}';
+   }
+   ```
+
+2. **Run the validator:** `statusdoc validate example.com`.
+
+If you build your own status page, `Document.to_dict()` produces a
+conforming document, and SPEC.md lists every field.
+
+## Status
+
+The spec is a 0.1 draft. The most useful contributions right now are
+feedback on the spec, new verified entries for the service list and adapters
+for other status page providers.
+
+## Related work
+
+- Atlassian Statuspage's public API, whose `summary.json` shape OSD specifies.
+- The expired IETF draft *Service Status Resource Format for Web Services*,
+  which proposed a new format instead.
+- Aggregators such as StatusGator (commercial) and Statusphere (open source),
+  which scrape status pages with one parser per provider.
+
+## License
+
+MIT

statusdoc-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "statusdoc"
+version = "0.1.0"
+description = "Open Status Document: a spec and tools to discover, read and validate service status pages"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Andrea Acanfora" }]
+requires-python = ">=3.10"
+dependencies = []
+keywords = ["status page", "statuspage", "incidents", "monitoring", "sre", "uptime"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: System :: Monitoring",
+  "Environment :: Console",
+]
+
+[project.urls]
+Homepage = "https://github.com/AndreaAcanfora/statusdoc"
+Specification = "https://github.com/AndreaAcanfora/statusdoc/blob/master/SPEC.md"
+
+[project.scripts]
+statusdoc = "statusdoc.cli:main"
+
+[tool.setuptools]
+packages = ["statusdoc"]
+
+[tool.setuptools.package-data]
+statusdoc = ["registry.json", "py.typed"]
+
+[tool.ruff]
+line-length = 160
+target-version = "py310"

statusdoc-0.1.0/setup.cfg

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

statusdoc-0.1.0/statusdoc/__init__.py

@@ -0,0 +1,26 @@
+"""Open Status Document: read, discover and validate service status pages."""
+
+__version__ = "0.1.0"
+
+from .adapters import detect, from_betterstack, load
+from .discover import Discovery, DiscoveryError, discover
+from .model import Component, Document, FormatError, Incident, Update, parse
+from .validate import Issue, validate_document, validate_http
+
+__all__ = [
+    "Component",
+    "Discovery",
+    "DiscoveryError",
+    "Document",
+    "FormatError",
+    "Incident",
+    "Issue",
+    "Update",
+    "detect",
+    "discover",
+    "from_betterstack",
+    "load",
+    "parse",
+    "validate_document",
+    "validate_http",
+]

statusdoc-0.1.0/statusdoc/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

statusdoc-0.1.0/statusdoc/adapters.py

@@ -0,0 +1,237 @@
+"""Readers for status formats that are not OSD yet."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .model import Component, Document, FormatError, Incident, Update, parse
+
+# Better Stack resource states → OSD component statuses.
+_BETTERSTACK_STATUS = {
+    "operational": "operational",
+    "maintenance": "under_maintenance",
+    "degraded": "degraded_performance",
+    "downtime": "major_outage",
+}
+_BETTERSTACK_SEVERITY = {"operational": 0, "under_maintenance": 1, "degraded_performance": 2, "partial_outage": 3, "major_outage": 4}
+_IMPACT_OF = {"degraded_performance": "minor", "partial_outage": "major", "major_outage": "critical"}
+_INDICATOR_OF = {0: "none", 1: "maintenance", 2: "minor", 3: "major", 4: "critical"}
+_DESCRIPTION_OF = {
+    0: "All Systems Operational",
+    1: "Service Under Maintenance",
+    2: "Partially Degraded Service",
+    3: "Partial System Outage",
+    4: "Major System Outage",
+}
+
+
+def detect(data: Any) -> str | None:
+    """Returns the format of a parsed JSON document, or None if unknown."""
+    if not isinstance(data, dict):
+        return None
+    if isinstance(data.get("page"), dict) and isinstance(data.get("status"), dict) and isinstance(data.get("components"), list):
+        return "osd"
+    d = data.get("data")
+    if isinstance(d, dict) and d.get("type") == "status_page" and isinstance(data.get("included"), list):
+        return "betterstack"
+    if isinstance(data.get("status"), str) and isinstance(data.get("active_incidents"), list):
+        return "slack"
+    return None
+
+
+def load(data: Any) -> Document:
+    """Reads a status document in any supported format."""
+    fmt = detect(data)
+    if fmt == "osd":
+        return parse(data)
+    if fmt == "betterstack":
+        return from_betterstack(data)
+    if fmt == "slack":
+        return from_slack(data)
+    raise FormatError("not a status document in a known format")
+
+
+def from_betterstack(data: dict[str, Any]) -> Document:
+    """Converts a Better Stack status page (`/index.json`, JSON:API) to OSD."""
+    page = data["data"].get("attributes", {})
+    included = [x for x in data["included"] if isinstance(x, dict)]
+
+    def of_type(t: str) -> list[dict[str, Any]]:
+        return [x for x in included if x.get("type") == t]
+
+    components: dict[str, Component] = {}
+    sections = {str(s.get("id")): s.get("attributes", {}) for s in of_type("status_page_section")}
+    for s_id, s in sections.items():
+        components["section-" + s_id] = Component(
+            id="section-" + s_id, name=str(s.get("name", "")).strip(), status="operational", group=True, position=s.get("position")
+        )
+    for r in of_type("status_page_resource"):
+        a = r.get("attributes", {})
+        if a.get("status") == "not_monitored":
+            # No data, so no claim either way: leave it out.
+            continue
+        section = a.get("status_page_section_id")
+        c = Component(
+            id=str(r.get("id")),
+            name=str(a.get("public_name", "")),
+            status=_BETTERSTACK_STATUS.get(str(a.get("status")), "degraded_performance"),
+            description=a.get("explanation") or None,
+            group_id=f"section-{section}" if section is not None and str(section) in sections else None,
+            position=a.get("position"),
+        )
+        components[c.id] = c
+    # A section is as bad as its worst resource.
+    for c in components.values():
+        if c.group_id:
+            group = components[c.group_id]
+            if _BETTERSTACK_SEVERITY[c.status] > _BETTERSTACK_SEVERITY[group.status]:
+                group.status = c.status
+
+    updates = {str(u.get("id")): u.get("attributes", {}) for u in of_type("status_update")}
+    incidents: list[Incident] = []
+    maintenances: list[Incident] = []
+    for report in of_type("status_report"):
+        a = report.get("attributes", {})
+        resolved = a.get("aggregate_state") == "resolved" or a.get("ends_at") is not None
+        affected = [
+            components[str(x.get("status_page_resource_id"))] for x in a.get("affected_resources", []) if str(x.get("status_page_resource_id")) in components
+        ]
+        worst = max((_BETTERSTACK_SEVERITY[c.status] for c in affected), default=0)
+        rel = report.get("relationships", {}).get("status_updates", {}).get("data", [])
+        report_updates = [updates[str(x.get("id"))] for x in rel if str(x.get("id")) in updates]
+        report_updates.sort(key=lambda u: str(u.get("published_at", "")), reverse=True)
+        is_maintenance = a.get("report_type") == "maintenance"
+        item = Incident(
+            id=str(report.get("id")),
+            name=str(a.get("title", "")),
+            status=("completed" if resolved else "in_progress") if is_maintenance else ("resolved" if resolved else "investigating"),
+            impact="none" if is_maintenance else _IMPACT_OF.get(_status_of(worst), "minor"),
+            created_at=str(a.get("starts_at", "")),
+            updates=[
+                Update(id=str(i), status="resolved" if resolved else "investigating", body=str(u.get("message", "")), created_at=str(u.get("published_at", "")))
+                for i, u in enumerate(report_updates)
+            ],
+            components=affected,
+            scheduled_for=a.get("starts_at") if is_maintenance else None,
+            scheduled_until=a.get("ends_at") if is_maintenance else None,
+        )
+        if is_maintenance:
+            if not resolved:
+                maintenances.append(item)
+        elif not resolved:
+            incidents.append(item)
+
+    # The page's own aggregate state is the publisher's judgement (spec section 4.3);
+    # fall back to the worst resource when it is missing.
+    aggregate = _BETTERSTACK_STATUS.get(str(page.get("aggregate_state")))
+    worst = _BETTERSTACK_SEVERITY[aggregate] if aggregate else max((_BETTERSTACK_SEVERITY[c.status] for c in components.values() if not c.group), default=0)
+    domain = page.get("custom_domain") or f"{page.get('subdomain', '')}.betteruptime.com"
+    return Document(
+        name=str(page.get("company_name", "")),
+        url=f"https://{domain}",
+        updated_at=str(page.get("updated_at", "")),
+        indicator=_INDICATOR_OF[worst],
+        description=_DESCRIPTION_OF[worst],
+        components=sorted(components.values(), key=lambda c: (c.group_id or c.id, not c.group, c.position or 0)),
+        incidents=incidents,
+        maintenances=maintenances,
+        source_format="betterstack",
+    )
+
+
+def _status_of(severity: int) -> str:
+    for status, s in _BETTERSTACK_SEVERITY.items():
+        if s == severity:
+            return status
+    return "operational"
+
+
+# Services listed by the Slack Status API documentation for /api/v2.0.0/current.
+SLACK_SERVICES = (
+    "Login/SSO",
+    "Messaging",
+    "Notifications",
+    "Search",
+    "Workspace/Org Administration",
+    "Canvases",
+    "Connectivity",
+    "Files",
+    "Huddles",
+    "Apps/Integrations/APIs",
+    "Workflows",
+)
+# Slack issue types → (OSD incident impact, status of the affected services).
+_SLACK_TYPES = {"outage": ("major", "major_outage"), "incident": ("minor", "degraded_performance"), "notice": ("none", "operational")}
+
+
+def from_slack(data: dict[str, Any]) -> Document:
+    """Converts the Slack Status API (`https://slack-status.com/api/v2.0.0/current`) to OSD.
+
+    Slack reports issues, not component states: affected services take the
+    status implied by the issue type (an outage makes them major_outage, an
+    incident degraded_performance, a notice leaves them operational).
+    """
+    services: dict[str, Component] = {}
+
+    def service(name: str) -> Component:
+        if name not in services:
+            slug = "".join(ch if ch.isalnum() else "-" for ch in name.lower()).strip("-")
+            services[name] = Component(id=slug, name=name, status="operational", position=len(services))
+        return services[name]
+
+    for name in SLACK_SERVICES:
+        service(name)
+
+    incidents: list[Incident] = []
+    maintenances: list[Incident] = []
+    worst = 0
+    for item in data.get("active_incidents", []):
+        if not isinstance(item, dict):
+            continue
+        status = str(item.get("status", ""))
+        kind = str(item.get("type", ""))
+        impact, service_status = _SLACK_TYPES.get(kind, ("minor", "degraded_performance"))
+        notes = [n for n in item.get("notes", []) if isinstance(n, dict)]
+        notes.sort(key=lambda n: str(n.get("date_created", "")), reverse=True)
+        affected = [service(str(s)) for s in item.get("services", []) if isinstance(s, str)]
+        entry = Incident(
+            id=str(item.get("id", "")),
+            name=str(item.get("title", "")),
+            status="",
+            impact=impact,
+            created_at=str(item.get("date_created", "")),
+            updated_at=item.get("date_updated"),
+            shortlink=item.get("url"),
+            updates=[
+                Update(id=f"{item.get('id', '')}-{n}", status="", body=str(note.get("body", "")), created_at=str(note.get("date_created", "")))
+                for n, note in enumerate(notes)
+            ],
+        )
+        if status in ("scheduled", "completed", "cancelled"):
+            if status == "scheduled":
+                entry.status, entry.impact = "scheduled", "none"
+                entry.scheduled_for = entry.created_at
+                maintenances.append(entry)
+            continue
+        entry.status = "resolved" if status == "resolved" else "investigating"
+        for u in entry.updates:
+            u.status = entry.status
+        if not entry.resolved:
+            for c in affected:
+                if _BETTERSTACK_SEVERITY[service_status] > _BETTERSTACK_SEVERITY[c.status]:
+                    c.status = service_status
+            worst = max(worst, {"none": 0, "minor": 2, "major": 3}[impact])
+        entry.components = [Component(id=c.id, name=c.name, status=c.status) for c in affected]
+        incidents.append(entry)
+
+    return Document(
+        name="Slack",
+        url="https://slack-status.com",
+        updated_at=str(data.get("date_updated", "")),
+        indicator=_INDICATOR_OF[worst],
+        description=_DESCRIPTION_OF[worst],
+        components=list(services.values()),
+        incidents=incidents,
+        maintenances=maintenances,
+        source_format="slack",
+    )