fly_io 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4dd8c23a72b3368728387726a4f9c0f549f964c73031fd210f8a452e0b635fed
+  data.tar.gz: 5c7cde4c9562e3a5e422b31c253f62eaa27de501e4ee80ef2a045c4934444f46
+SHA512:
+  metadata.gz: 537aacc7de6c237c6acfb03107d96c4244ba0e94338e819ec5ac9bd16ca2af122b25abcc143f9e58eee2eeb43d35f70b990f120546266c1db87417ab9eb142a3
+  data.tar.gz: 18fb6ba50789303ed0b90154dd650822accbd1c21d4852afbd3bec80876b21167e5597e2f2b5c714c8acff081c17145c46038897eac192d6b1ed2f38a753b2fe

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes follow [Keep a Changelog](https://keepachangelog.com/) and Semantic Versioning.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-26
+
+### Added
+
+- Complete generated coverage of the Fly Machines OpenAPI contract: 98 operations and 173 schemas.
+- Documentation-derived Network Policies client.
+- Seven-family Fly Prometheus compatibility client.
+- Raw GraphQL client and explicitly experimental flyctl/fly-go/official operation inventory.
+- Typed responses, redaction, bounded safe retries, contract drift gates, offline tests, and packaging/CI workflows.

data/CONTRIBUTING.md

@@ -0,0 +1,14 @@
+# Contributing
+
+Use Ruby 4.0.6 for development. Run `bundle install`, then `bundle exec rake` before opening a change.
+
+API changes start from committed evidence, not handwritten endpoint lists:
+
+1. Run `bundle exec rake api:fetch_check` to detect Machines OpenAPI drift.
+2. Review upstream changes and update the relevant snapshot plus provenance/hash.
+3. Run `bundle exec rake api:generate`.
+4. Add readable behavior coverage when semantics or risk changes.
+5. Run `bundle exec rake`, `bundle exec bundle-audit check --update`, and the install smoke test.
+
+Do not add undocumented flyctl calls to the stable namespace. GraphQL evidence stays experimental. Never commit tokens,
+live response cassettes, credentials, or unredacted debug output.

data/LICENSE

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

data/README.md

@@ -0,0 +1,239 @@
+# fly_io
+
+`fly_io` is a contract-driven Ruby client for Fly.io’s documented platform APIs. It covers every operation in the
+Machines REST OpenAPI contract, the documentation-only Network Policies endpoints, Fly’s Prometheus compatibility
+endpoint, and Fly’s explicitly unstable control-plane GraphQL boundary.
+
+The Ruby namespace is `FlyIO`. The gem name was unclaimed on RubyGems when checked on 2026-08-26; see
+[`contracts/research_metadata.json`](contracts/research_metadata.json). This repository is not published by or
+affiliated with Fly.io.
+
+## Installation
+
+Add the gem to your bundle:
+
+```ruby
+gem "fly_io", "~> 0.1"
+```
+
+Then run `bundle install`. Ruby 3.2 or newer is supported. Development and the primary CI job use Ruby 4.0.6, the
+latest stable release verified from ruby-lang.org on the contract retrieval date.
+
+The sole runtime dependency is Faraday 2.x. It provides a maintained, adapter-injectable HTTP foundation; retries,
+redaction, contract mapping, and model coercion are implemented in this gem so their behavior remains explicit.
+
+## Quickstart
+
+```ruby
+require "fly_io"
+
+client = FlyIO::Client.new(token: ENV.fetch("FLY_API_TOKEN"))
+
+apps = client.apps.list(org_slug: "personal")
+machine = client.machines.create(
+  app_name: "my-app",
+  body: {
+    region: "iad",
+    config: {
+      image: "registry.example.com/my-image:latest",
+      guest: {cpu_kind: "shared", cpus: 1, memory_mb: 512}
+    }
+  }
+)
+
+client.machines.start(app_name: "my-app", machine_id: machine.id)
+client.machines.wait(app_name: "my-app", machine_id: machine.id, state: "started", timeout: 60)
+```
+
+Resource methods return `FlyIO::Response`. `response.body` is coerced to the documented `FlyIO::Models::*` class (or
+an array/primitive where the contract says so), while response methods delegate to a model for concise code such as
+`machine.id`. Models keep unknown fields and preserve exact wire keys for forward compatibility.
+
+All named endpoint inputs are keyword arguments. JSON request bodies use `body:` because this gives every generated
+operation one consistent signature. The generated [complete API reference](docs/API.md) maps each Ruby method to the
+official operation ID, method, and path.
+
+## Authentication
+
+The official Machines guide and current examples use `Authorization: Bearer <token>`. The generated reference also
+contains contradictory `FlyV1` prose. Consequently, a raw token uses `Bearer` by default and preformatted values are
+explicit:
+
+```ruby
+FlyIO::Client.new(token: ENV.fetch("FLY_API_TOKEN"))
+FlyIO::Client.new(authorization: "FlyV1 #{ENV.fetch("FLY_MACAROON")}")
+FlyIO::Client.new(token: ENV.fetch("FLY_MACAROON"), authorization_mode: :fly_v1)
+```
+
+A token passed to `token:` must be raw, so `Bearer Bearer ...` cannot be produced accidentally. Authorization values,
+tokens, secrets, passwords, credentials, private keys, and certificates are filtered from logs, request metadata, and
+exceptions.
+
+## Configuration and transport behavior
+
+```ruby
+configuration = FlyIO::Configuration.new(
+  token: ENV.fetch("FLY_API_TOKEN"),
+  base_url: "https://api.machines.dev",       # or http://_api.internal:4280 on the Fly private network
+  graphql_url: "https://api.fly.io/graphql",
+  metrics_url: "https://api.fly.io",
+  open_timeout: 10,
+  read_timeout: 30,
+  write_timeout: 30,
+  request_timeout: 45,
+  proxy: ENV["HTTPS_PROXY"],
+  user_agent: "my-service/1.0 fly_io/#{FlyIO::VERSION}",
+  max_retries: 2,
+  base_retry_interval: 0.25,
+  max_retry_interval: 5,
+  retry_jitter: 0.25,
+  logger: Logger.new($stderr)
+)
+client = FlyIO::Client.new(configuration)
+```
+
+TLS verification is always enabled by the HTTP adapter. The client parses JSON only when the response content type is
+JSON, represents 204 as a nil body, preserves 202 responses, and safely returns text, binary, empty, or malformed JSON
+bodies. `FlyIO::Response` includes status, headers, parsed body, raw body, safe request metadata, and Fly’s request ID.
+
+GET/HEAD/OPTIONS requests retry bounded transient connection failures and 408, 429, 500, 502, 503, and 504 responses.
+`Retry-After` is honored; otherwise delay uses capped exponential backoff with jitter. Unsafe methods are never retried
+unless a caller passes `retry_unsafe: true` to that request or deliberately enables it globally. Fly’s limits are
+per-action and per-resource, so this gem does not pretend a single client-wide throttle is correct.
+
+Configuration and resource objects are immutable. All request state is local, making a client safe to share between
+threads. An object responding to `call(method:, url:, headers:, body:, timeout:)` can be supplied as `adapter:` for
+dependency injection; a Faraday adapter symbol is also accepted.
+
+## Errors
+
+All failures inherit `FlyIO::Error`. HTTP failures use `FlyIO::APIError` and its typed subclasses:
+
+- `AuthenticationError` / `AuthorizationError`
+- `NotFoundError`
+- `ValidationError`
+- `RateLimitError`
+- `RequestTimeoutError`
+- `TransportError`
+- `ServerError`
+- `GraphQLError`
+
+API errors retain status, safe headers, redacted parsed details, request ID, and redacted request metadata.
+
+## Raw REST and operation-ID access
+
+Use a path template when values are dynamic so every component is escaped independently:
+
+```ruby
+client.request(
+  method: :get,
+  path: "/v1/apps/{app_name}/machines",
+  path_params: {app_name: "my-app"},
+  query: {state: "started"}
+)
+
+client.operation("Machines_start", app_name: "my-app", machine_id: "machine-id")
+```
+
+The low-level API validates the method, rejects path traversal and URL-shaped paths, supports repeated query values,
+and returns the same response/errors as resource methods. The upstream duplicate `Machines_update_metadata` ID must be
+disambiguated with `method:` and `path:`.
+
+## Network Policies
+
+Fly officially documents three Network Policies operations that are missing from its OpenAPI document:
+
+```ruby
+client.network_policies.upsert(
+  app_name: "my-app",
+  body: {
+    name: "web-egress",
+    selector: {metadata: {role: "web"}},
+    rules: [{action: "allow", direction: "egress", ports: [{protocol: "tcp", port: 443}]}]
+  }
+)
+client.network_policies.list(app_name: "my-app")
+client.network_policies.delete(app_name: "my-app", policy_id: "policy-id")
+```
+
+The guide does not document response statuses or schemas. Responses therefore remain forward-compatible raw values;
+the body input is checked only against fields and constraints the guide actually states.
+
+## Prometheus metrics
+
+Fly documents seven Prometheus-compatible endpoint families at `https://api.fly.io/prometheus/<org>/`. They are a
+stable observability/data API, not control-plane operations, but are included so the platform-surface audit is honest:
+
+```ruby
+client.metrics.query(org_slug: "personal", query: 'sum(rate(fly_edge_http_responses_count[5m]))')
+client.metrics.query_range(org_slug: "personal", query: "up", start: "-1h", end: "now", step: "60s")
+client.metrics.series(org_slug: "personal", match: ['{__name__="up"}'])
+client.metrics.labels(org_slug: "personal")
+client.metrics.label_values(org_slug: "personal", label_name: "app")
+client.metrics.tsdb(org_slug: "personal")
+client.metrics.federate(org_slug: "personal", match: ["up"])
+```
+
+The JSON envelope becomes `FlyIO::Models::PrometheusAPIResponse`; federation remains text. Endpoint semantics are
+delegated to the stable Prometheus HTTP API and Fly’s stated VictoriaMetrics compatibility.
+
+## GraphQL: experimental and unstable
+
+Fly explicitly documents `https://api.fly.io/graphql` as an internal flyctl interface with no stability guarantees.
+It can change without notice. Prefer REST or flyctl where possible. Nothing in this gem presents GraphQL fields as a
+stable public contract.
+
+Raw documents, variables, operation names, response parsing, errors, timeouts, and opt-in retries are first class:
+
+```ruby
+graphql = client.graphql
+response = graphql.query(
+  document: "query App($name: String!) { app(name: $name) { id name } }",
+  variables: {name: "my-app"},
+  operation_name: "App"
+)
+```
+
+Schema introspection is double opt-in: construct configuration with `introspection: true`, then call
+`graphql.introspect(document: ...)`. The committed flyctl schema is evidence only.
+
+The experimental adapter inventories 29 current flyctl documents, 85 fly-go v0.9.8 documents, and 3 official unstable
+examples. Execute one with `graphql.experimental.execute("flyctl.GetApp", variables: ...)`. Arbitrary raw GraphQL
+documents remain available when Fly adds fields before this gem releases.
+
+## Contracts, development, and tests
+
+The [surface inventory](docs/SURFACES.md) records every selected/excluded surface, provenance, hashes, revisions,
+counts, stability, and gaps. Contract artifacts live under `contracts/`; generated runtime metadata is under
+`lib/fly_io/generated/`.
+
+```shell
+bundle install
+bundle exec rake api:check   # offline snapshot/ref/mapping/generated-drift checks
+bundle exec rspec            # offline; WebMock disables all network access
+bundle exec rubocop
+bundle exec bundle-audit check --update
+bundle exec rake build
+```
+
+For an isolated `--install-dir` smoke under RubyGems 4, use `--ignore-dependencies` for the target gem and include the
+already audited Bundler gem path when requiring it. RubyGems otherwise attempts to rediscover Faraday in a local gem
+repository even when it is already installed. CI performs this install plus a packaged-gem require check.
+
+`bundle exec rake api:fetch_check` is the explicit networked upstream-drift check. `script/generate_api` regenerates
+operation/model metadata and [docs/API.md](docs/API.md). Generated code is included in coverage because the small
+runtime generator boundary is exercised by contract-derived RSpec examples; JSON metadata itself has no executable
+lines to exclude.
+
+Live tests require `FLY_IO_LIVE_TESTS=1`, `FLY_API_TOKEN`, and `FLY_IO_TEST_APP`. Destructive live work additionally
+requires `FLY_IO_DESTRUCTIVE_LIVE_TESTS=1`; ordinary CI never has network access or credentials.
+
+## Versioning
+
+The gem follows Semantic Versioning for its own stable Ruby API. Machines contract changes are reviewed through the
+drift gate. Experimental GraphQL changes may ship in any release and are called out in the changelog because Fly gives
+that upstream interface no compatibility guarantee.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ["--cache-root", "tmp/rubocop_cache", "--no-server"]
+end
+
+namespace :api do
+  desc "Verify generated API coverage and committed contract outputs"
+  task :check do
+    sh RbConfig.ruby, "script/check_api_coverage"
+  end
+
+  desc "Fetch the upstream OpenAPI and fail if it differs from the snapshot"
+  task :fetch_check do
+    sh RbConfig.ruby, "script/fetch_openapi"
+  end
+
+  desc "Regenerate API metadata and documentation"
+  task :generate do
+    sh RbConfig.ruby, "script/generate_api"
+  end
+end
+
+desc "Run offline quality checks"
+task default: ["api:check", :spec, :rubocop]

data/contracts/additional_rest/network_policies.json

@@ -0,0 +1,94 @@
+{
+  "surface": "network_policies_rest",
+  "stability": "stable_documented",
+  "base_url": "https://api.machines.dev",
+  "documentation_url": "https://fly.io/docs/machines/guides-examples/network-policies/",
+  "source_repository": "https://github.com/superfly/docs",
+  "source_revision": "1e8cac5f0fd7a82e66e3b01ece3a10a8ecb2b7e3",
+  "source_path": "machines/guides-examples/network-policies.html.markerb",
+  "source_sha256": "fa64b69db56beb1da2de60e3ff91820b628a1238a120d103c2f3bae16e2fcc1f",
+  "retrieved_at": "2026-08-26T21:00:00Z",
+  "limitations": [
+    "This official guide is not represented in the Machines OpenAPI document.",
+    "The guide documents methods, paths, authentication, and request shape, but no response status or schema."
+  ],
+  "schemas": {
+    "NetworkPolicyPort": {
+      "type": "object",
+      "required": ["protocol", "port"],
+      "properties": {"protocol": {"type": "string"}, "port": {"type": "integer"}}
+    },
+    "NetworkPolicyRule": {
+      "type": "object",
+      "required": ["action", "direction", "ports"],
+      "properties": {
+        "action": {"type": "string", "enum": ["allow"]},
+        "direction": {"type": "string", "enum": ["ingress", "egress"]},
+        "ports": {"type": "array", "items": {"$ref": "#/additional/schemas/NetworkPolicyPort"}}
+      }
+    },
+    "NetworkPolicySelector": {
+      "type": "object",
+      "properties": {
+        "all": {"type": "boolean"},
+        "machines": {"type": "array", "items": {"type": "object", "required": ["id"], "properties": {"id": {"type": "string"}}}},
+        "metadata": {"type": "object", "additionalProperties": {"type": "string"}}
+      }
+    },
+    "NetworkPolicyRequest": {
+      "type": "object",
+      "required": ["name", "selector", "rules"],
+      "properties": {
+        "id": {"type": "string"},
+        "name": {"type": "string"},
+        "selector": {"$ref": "#/additional/schemas/NetworkPolicySelector"},
+        "rules": {"type": "array", "items": {"$ref": "#/additional/schemas/NetworkPolicyRule"}}
+      }
+    },
+    "NetworkPolicy": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "id": {"type": "string"},
+        "name": {"type": "string"},
+        "selector": {"$ref": "#/additional/schemas/NetworkPolicySelector"},
+        "rules": {"type": "array", "items": {"$ref": "#/additional/schemas/NetworkPolicyRule"}}
+      }
+    }
+  },
+  "operations": [
+    {
+      "identity": "POST /v1/apps/{app_name}/network_policies NetworkPolicies_upsert",
+      "operation_id": "NetworkPolicies_upsert",
+      "method": "post",
+      "path": "/v1/apps/{app_name}/network_policies",
+      "summary": "Create or update a network policy",
+      "parameters": [{"name": "app_name", "ruby_name": "app_name", "in": "path", "required": true, "schema": {"type": "string"}}],
+      "request_body": {"required": true, "content_types": ["application/json"], "schema": {"$ref": "#/additional/schemas/NetworkPolicyRequest"}},
+      "responses": {}
+    },
+    {
+      "identity": "GET /v1/apps/{app_name}/network_policies/ NetworkPolicies_list",
+      "operation_id": "NetworkPolicies_list",
+      "method": "get",
+      "path": "/v1/apps/{app_name}/network_policies/",
+      "summary": "List network policies",
+      "parameters": [{"name": "app_name", "ruby_name": "app_name", "in": "path", "required": true, "schema": {"type": "string"}}],
+      "request_body": null,
+      "responses": {}
+    },
+    {
+      "identity": "DELETE /v1/apps/{app_name}/network_policies/{policy_id} NetworkPolicies_delete",
+      "operation_id": "NetworkPolicies_delete",
+      "method": "delete",
+      "path": "/v1/apps/{app_name}/network_policies/{policy_id}",
+      "summary": "Delete a network policy",
+      "parameters": [
+        {"name": "app_name", "ruby_name": "app_name", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "policy_id", "ruby_name": "policy_id", "in": "path", "required": true, "schema": {"type": "string"}}
+      ],
+      "request_body": null,
+      "responses": {}
+    }
+  ]
+}

data/contracts/additional_rest/prometheus.json

@@ -0,0 +1,103 @@
+{
+  "surface": "prometheus_metrics",
+  "stability": "stable_standard_api_with_qualified_compatibility",
+  "base_url": "https://api.fly.io",
+  "documentation_url": "https://fly.io/docs/monitoring/metrics",
+  "source_repository": "https://github.com/superfly/docs",
+  "source_revision": "1e8cac5f0fd7a82e66e3b01ece3a10a8ecb2b7e3",
+  "source_path": "monitoring/metrics.html.md",
+  "source_sha256": "e22d7b34406b16c2ea75eed6cd92c51ec07d166963155623557295ef24f67e9f",
+  "retrieved_at": "2026-08-26T21:00:00Z",
+  "limitations": [
+    "This is an observability data API, not a control-plane API.",
+    "Fly documents support for most common Prometheus query endpoints and delegates their parameter/response contracts to Prometheus/VictoriaMetrics."
+  ],
+  "schemas": {
+    "PrometheusAPIResponse": {
+      "type": "object",
+      "required": ["status"],
+      "additionalProperties": true,
+      "properties": {
+        "status": {"type": "string", "enum": ["success", "error"]},
+        "data": {"type": "object", "additionalProperties": true},
+        "errorType": {"type": "string"},
+        "error": {"type": "string"},
+        "warnings": {"type": "array", "items": {"type": "string"}},
+        "infos": {"type": "array", "items": {"type": "string"}}
+      }
+    }
+  },
+  "operations": [
+    {
+      "operation_id": "Prometheus_query", "method": "get", "path": "/prometheus/{org_slug}/api/v1/query",
+      "summary": "Run an instant Prometheus query",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "query", "ruby_name": "query", "in": "query", "required": true, "schema": {"type": "string"}},
+        {"name": "time", "ruby_name": "time", "in": "query", "required": false, "schema": {"type": "string"}},
+        {"name": "timeout", "ruby_name": "timeout", "in": "query", "required": false, "schema": {"type": "string"}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_query_range", "method": "get", "path": "/prometheus/{org_slug}/api/v1/query_range",
+      "summary": "Run a range Prometheus query",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "query", "ruby_name": "query", "in": "query", "required": true, "schema": {"type": "string"}},
+        {"name": "start", "ruby_name": "start", "in": "query", "required": true, "schema": {"type": "string"}},
+        {"name": "end", "ruby_name": "end", "in": "query", "required": true, "schema": {"type": "string"}},
+        {"name": "step", "ruby_name": "step", "in": "query", "required": true, "schema": {"type": "string"}},
+        {"name": "timeout", "ruby_name": "timeout", "in": "query", "required": false, "schema": {"type": "string"}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_series", "method": "get", "path": "/prometheus/{org_slug}/api/v1/series",
+      "summary": "Find series by label matchers",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "match[]", "ruby_name": "match", "in": "query", "required": true, "schema": {"type": "array", "items": {"type": "string"}}},
+        {"name": "start", "ruby_name": "start", "in": "query", "required": false, "schema": {"type": "string"}},
+        {"name": "end", "ruby_name": "end", "in": "query", "required": false, "schema": {"type": "string"}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_labels", "method": "get", "path": "/prometheus/{org_slug}/api/v1/labels",
+      "summary": "Get label names",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "match[]", "ruby_name": "match", "in": "query", "required": false, "schema": {"type": "array", "items": {"type": "string"}}},
+        {"name": "start", "ruby_name": "start", "in": "query", "required": false, "schema": {"type": "string"}},
+        {"name": "end", "ruby_name": "end", "in": "query", "required": false, "schema": {"type": "string"}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_label_values", "method": "get", "path": "/prometheus/{org_slug}/api/v1/label/{label_name}/values",
+      "summary": "Get values for a label",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "label_name", "ruby_name": "label_name", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "match[]", "ruby_name": "match", "in": "query", "required": false, "schema": {"type": "array", "items": {"type": "string"}}},
+        {"name": "start", "ruby_name": "start", "in": "query", "required": false, "schema": {"type": "string"}},
+        {"name": "end", "ruby_name": "end", "in": "query", "required": false, "schema": {"type": "string"}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_tsdb", "method": "get", "path": "/prometheus/{org_slug}/api/v1/status/tsdb",
+      "summary": "Get TSDB statistics",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "limit", "ruby_name": "limit", "in": "query", "required": false, "schema": {"type": "integer"}},
+        {"name": "match[]", "ruby_name": "match", "in": "query", "required": false, "schema": {"type": "array", "items": {"type": "string"}}}
+      ]
+    },
+    {
+      "operation_id": "Prometheus_federate", "method": "get", "path": "/prometheus/{org_slug}/federate",
+      "summary": "Federate selected metrics",
+      "parameters": [
+        {"name": "org_slug", "ruby_name": "org_slug", "in": "path", "required": true, "schema": {"type": "string"}},
+        {"name": "match[]", "ruby_name": "match", "in": "query", "required": true, "schema": {"type": "array", "items": {"type": "string"}}}
+      ],
+      "response_content_type": "text/plain"
+    }
+  ]
+}