Datadog·Grafana 연동

import os
import requests

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com").rstrip("/")
TOKEN = os.environ["INNORIX_ACCESS_TOKEN"]
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")   # optional; falls back to the current workspace

STATUS_COMPLETE = 2
TERMINAL = {2, 4, 5, 9, 99}          # complete / error / cancelled / partial / failed
NOT_SUCCEEDED = {4, 5, 9, 99}


def api(method, path, body=None, params=None):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    }

    if WORKSPACE_ID:
        headers["x-workspace-id"] = WORKSPACE_ID

    response = requests.request(
        method, BASE_URL + path,
        headers=headers, json=body, params=params, timeout=30,
    )

    payload = response.json() if response.content else {}

    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")

    return payload.get("data")


def is_terminal(detail):
    return detail.get("isTerminal", detail.get("status") in TERMINAL)

def paginate(path, params=None, limit=200, max_pages=50):
    query = dict(params or {})
    query["limit"] = limit
    cursor = None

    for _ in range(max_pages):
        if cursor:
            query["cursor"] = cursor

        result = api("GET", path, params=query) or {}

        for record in result.get("data") or []:
            yield record

        pagination = result.get("pagination") or {}

        if not pagination.get("hasMore"):
            return

        cursor = pagination.get("nextCursor")

        if not cursor:
            return

def poll_active(automation_id=None):
    params = {"automationId": automation_id} if automation_id else None
    return list(paginate("/api/transfers", params=params, limit=50))


# list items expose id/progress; totalSize·fileCount live under detail
for record in poll_active():
    print(record["id"], record["statusName"], record.get("progress", 0),
          record["sourceDeviceName"], record["targetDeviceName"])

def poll_devices():
    result = api("GET", "/api/devices", params={"page": 1, "size": 200}) or {}

    for device in result.get("devices") or []:
        state = api("GET", f"/api/devices/{device['deviceId']}/connectivity") or {}
        yield device["deviceId"], device["name"], bool(state.get("isConnected"))

from collections import Counter
from datetime import datetime, timedelta, timezone


def window(days):
    end = datetime.now(timezone.utc)
    fmt = "%Y-%m-%dT%H:%M:%SZ"
    return (end - timedelta(days=days)).strftime(fmt), end.strftime(fmt)


def history(days=1, device_id=None):
    start, end = window(days)
    params = {"startDate": start, "endDate": end}

    path = (f"/api/devices/{device_id}/transfer-history" if device_id
            else "/api/transfer-history")

    return list(paginate(path, params=params, limit=200))


def summarize(rows):
    counts = Counter(row.get("status") for row in rows)
    total = sum(counts.values())
    failed = sum(counts.get(code, 0) for code in NOT_SUCCEEDED)

    return {
        "total": total,
        "completed": counts.get(STATUS_COMPLETE, 0),
        "failed": failed,
        "failure_rate": failed / total if total else 0.0,
    }

def export_csv(days, out_path):
    params = {
        "periodDays": days,
        "page": 1,
        "size": 10000,
        "filter": "[]",              # the server parses this as a JSON string, so send an empty array
        "sort": "startDate:desc",
    }

    response = requests.get(
        BASE_URL + "/api/transfer-history/export",
        headers={"Authorization": f"Bearer {TOKEN}"},
        params=params, timeout=120,
    )

    if not response.ok:
        raise RuntimeError(response.text[:200])

    with open(out_path, "w", encoding="utf-8-sig") as handle:
        handle.write(response.text)

import time


def build_metrics(active_count, summary, devices):
    now = int(time.time())

    points = [
        {"metric": "innorix.transfer.active", "value": active_count, "tags": []},
        {"metric": "innorix.transfer.completed",
         "value": summary["completed"], "tags": []},
        {"metric": "innorix.transfer.failed",
         "value": summary["failed"], "tags": []},
        {"metric": "innorix.transfer.failure_rate",
         "value": round(summary["failure_rate"], 4), "tags": []},
    ]

    for device_id, name, connected in devices:
        points.append({
            "metric": "innorix.device.connected",
            "value": 1 if connected else 0,
            "tags": [f"device:{name}"],
        })

    return [{**p, "timestamp": now} for p in points]

rules = api("GET", "/api/integrations/rules",
            params={"category": "monitoring"}) or {}

for name, rule in rules.items():
    print(name, rule.get("category"), rule.get("modes"))

    for field in rule.get("fields") or []:
        mark = "required" if field.get("required") else "optional"
        print("   ", field["id"], field["label"], field["type"], mark)

data = api("GET", "/api/integrations/rules/slack") or {}
rule = data.get("slack") or next(iter(data.values()), {})

VALID_EVENTS = ["started", "completed", "paused", "resumed",
                "recovered", "canceled", "error", "skipped"]

api("POST", "/api/integrations", {
    "name": "transfer alerts",
    "type": "slack",
    "mode": "webhook",
    "webhookUrl": WEBHOOK_URL,
    "config": {
        "name": "transfer alerts",
        "webhookUrl": WEBHOOK_URL,
        "channel": "#file-ops",
    },
    # toggle per event; this is what wires transfer events to the integration
    "notificationConfig": {"events": {"completed": True, "error": True}},
})