NoxHash APIでマイナーをプログラマティックに監視する方法

import os, time, requests
from datetime import datetime, timedelta, timezone

API_BASE = "https://api.noxhash.com/v1"   # confirm in current docs
API_KEY  = os.environ["NOXHASH_API_KEY"]  # never hard-code
OFFLINE_THRESHOLD = timedelta(minutes=30)

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
}

def fetch_miners():
    r = requests.get(f"{API_BASE}/miners", headers=headers, timeout=10)
    r.raise_for_status()
    return r.json().get("data", [])

def check_offline(miners):
    now = datetime.now(timezone.utc)
    alerts = []
    for m in miners:
        if m["status"] != "running":
            last_seen = datetime.fromisoformat(m["last_seen_at"])
            if now - last_seen > OFFLINE_THRESHOLD:
                alerts.append(m)
    return alerts

def send_sms(miner):
    # plug in Twilio / Vonage / a webhook to your phone
    print(f"ALERT: {miner['name']} offline since {miner['last_seen_at']}")

if __name__ == "__main__":
    while True:
        try:
            for miner in check_offline(fetch_miners()):
                send_sms(miner)
        except requests.HTTPError as e:
            print(f"API error: {e}")
        time.sleep(300)  # poll every 5 minutes — be kind to the API

const API_BASE = "https://api.noxhash.com/v1";
const API_KEY  = process.env.NOXHASH_API_KEY;
const OFFLINE_MS = 30 * 60 * 1000;

async function fetchMiners() {
  const res = await fetch(`${API_BASE}/miners`, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data } = await res.json();
  return data;
}

function offlineAlerts(miners) {
  const now = Date.now();
  return miners.filter(m =>
    m.status !== "running" &&
    now - new Date(m.last_seen_at).getTime() > OFFLINE_MS
  );
}

setInterval(async () => {
  try {
    const alerts = offlineAlerts(await fetchMiners());
    alerts.forEach(m => console.log(`ALERT: ${m.name} offline`));
  } catch (e) { console.error(e.message); }
}, 5 * 60 * 1000);