API Documentation

Authorization: Bearer YOUR_API_KEY

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1609459200

{
  "status": "error",
  "message": "Invalid API key",
  "code": 401
}

curl -X GET "https://mycompany.slyfox.su/v1/monitors?page=1&per_page=10" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

{
  "status": "success",
  "data": [
    {
      "id": "m789012",
      "friendly_name": "Основной веб-сервер",
      "url": "https://example.com",
      "type": "HTTP(s)",
      "status": "online",
      "response_time": 124,
      "last_check": "2025-11-04T14:30:22Z",
      "uptime_ratio": 99.98,
      "custom_uptime_ratio": "99.95",
      "average_response_time": 142,
      "monitor_group": "Production",
      "created_at": "2025-01-15T08:30:00Z"
    }
  ],
  "meta": {
    "total": 1,
    "page": 1,
    "per_page": 10,
    "total_pages": 1
  }
}

curl -X POST "https://mycompany.slyfox.su/v1/monitors" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "friendly_name": "Мой веб-сайт",
    "url": "https://mywebsite.com",
    "type": "HTTP(s)",
    "interval": 300
  }'

{
  "status": "success",
  "data": {
    "id": "m987654",
    "friendly_name": "Мой веб-сайт",
    "url": "https://mywebsite.com",
    "type": "HTTP(s)",
    "status": "pending",
    "response_time": 0,
    "last_check": null,
    "uptime_ratio": 0,
    "custom_uptime_ratio": "0",
    "average_response_time": 0,
    "monitor_group": null,
    "created_at": "2025-11-04T15:30:00Z"
  }
}

curl -X PUT "https://mycompany.slyfox.su/v1/monitors/m987654" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "friendly_name": "Обновленный веб-сайт",
    "interval": 600
  }'

curl -X DELETE "https://mycompany.slyfox.su/v1/monitors/m987654" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl -X POST "https://mycompany.slyfox.su/v1/monitors/m987654/pause" \
  -H "Authorization: Bearer YOUR_API_KEY"

curl -X POST "https://mycompany.slyfox.su/v1/monitors/m987654/resume" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "event": "monitor_status_change",
  "timestamp": "2025-11-04T14:30:22Z",
  "data": {
    "monitor_id": "m789012",
    "monitor_name": "Основной веб-сервер",
    "previous_status": "online",
    "current_status": "offline",
    "response_time": 0,
    "error_message": "Connection timeout"
  }
}

// JavaScript (fetch API)
const response = await fetch('https://mycompany.slyfox.su/v1/monitors', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log('Статус мониторов:', data);

# Python (requests library)
import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}

response = requests.get('https://mycompany.slyfox.su/v1/monitors', headers=headers)
data = response.json()
print(f'Статус мониторов: {data}')

// JavaScript с обработкой ошибок
async function createMonitor(monitorData) {
  try {
    const response = await fetch('https://mycompany.slyfox.su/v1/monitors', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(monitorData)
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Ошибка API: ${error.message}`);
    }

    const result = await response.json();
    console.log('Монитор создан:', result.data);
    return result.data;
  } catch (error) {
    console.error('Ошибка при создании монитора:', error.message);
    throw error;
  }
}

const newMonitor = {
  friendly_name: 'Мой веб-сервис',
  url: 'https://mywebsite.com',
  type: 'HTTP(s)',
  interval: 300
};

createMonitor(newMonitor);

# Python - автоматическое восстановление сервисов
import requests
import time
import subprocess

class ServiceMonitor:
    def __init__(self, api_key):
        self.api_key = api_key
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

    def get_monitor_status(self, monitor_id):
        """Получить статус конкретного монитора"""
        url = f'https://mycompany.slyfox.su/v1/monitors/{monitor_id}'
        response = requests.get(url, headers=self.headers)
        return response.json()

    def restart_service(self, service_name):
        """Перезапустить сервис (пример для Linux)"""
        try:
            result = subprocess.run(['systemctl', 'restart', service_name],
                                  capture_output=True, text=True)
            return result.returncode == 0
        except Exception as e:
            print(f'Ошибка перезапуска: {e}')
            return False

    def monitor_and_recover(self, monitor_id, service_name, check_interval=60):
        """Мониторить сервис и автоматически перезапускать при падении"""
        print(f'Начинаем мониторинг сервиса {service_name}')

        while True:
            try:
                status = self.get_monitor_status(monitor_id)

                if status['data']['status'] == 'offline':
                    print(f'Сервис {service_name} упал. Пытаемся перезапустить...')
                    if self.restart_service(service_name):
                        print(f'Сервис {service_name} успешно перезапущен')
                    else:
                        print(f'Ошибка перезапуска сервиса {service_name}')

                time.sleep(check_interval)

            except Exception as e:
                print(f'Ошибка мониторинга: {e}')
                time.sleep(check_interval)

# monitor = ServiceMonitor('YOUR_API_KEY')
# monitor.monitor_and_recover('monitor_id_123', 'my-web-service')

// JavaScript - анализ доступности сервисов
async function generateAvailabilityReport() {
  try {
    const response = await fetch('https://mycompany.slyfox.su/v1/monitors', {
      method: 'GET',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });

    const data = await response.json();
    const monitors = data.data;

    console.log('=== Отчет о доступности сервисов ===');

    monitors.forEach(monitor => {
      const uptime = monitor.custom_uptime_ratio || monitor.uptime_ratio;
      const statusEmoji = monitor.status === 'online' ? '✅' : '❌';

      console.log(`${statusEmoji} ${monitor.friendly_name}`);
      console.log(`  URL: ${monitor.url}`);
      console.log(`  Доступность: ${uptime}%`);
      console.log(`  Среднее время отклика: ${monitor.average_response_time}ms`);
      console.log(`  Последняя проверка: ${monitor.last_check}`);
      console.log('---');
    });

    const totalMonitors = monitors.length;
    const onlineMonitors = monitors.filter(m => m.status === 'online').length;
    const averageUptime = monitors.reduce((sum, m) => sum + parseFloat(m.uptime_ratio), 0) / totalMonitors;

    console.log(`\nОбщая статистика:`);
    console.log(`  Всего сервисов: ${totalMonitors}`);
    console.log(`  Работают: ${onlineMonitors}/${totalMonitors}`);
    console.log(`  Средняя доступность: ${averageUptime.toFixed(2)}%`);

  } catch (error) {
    console.error('Ошибка генерации отчета:', error);
  }
}

generateAvailabilityReport();

# Python - интеграция с Telegram
import requests
import json

class TelegramNotifier:
    def __init__(self, bot_token, chat_id):
        self.bot_token = bot_token
        self.chat_id = chat_id
        self.api_url = f'https://api.telegram.org/bot{bot_token}'

    def send_message(self, message):
        """Отправить сообщение в Telegram"""
        url = f'{self.api_url}/sendMessage'
        data = {
            'chat_id': self.chat_id,
            'text': message,
            'parse_mode': 'Markdown'
        }

        try:
            response = requests.post(url, data=data)
            return response.json().get('ok', False)
        except Exception as e:
            print(f'Ошибка отправки в Telegram: {e}')
            return False

def monitor_status_changes(api_key, bot_token, chat_id):
    """Мониторить изменения статуса и отправлять уведомления"""
    notifier = TelegramNotifier(bot_token, chat_id)

    headers = {
        'Authorization': f'Bearer {api_key}',
        'Content-Type': 'application/json'
    }

    response = requests.get('https://mycompany.slyfox.su/v1/monitors', headers=headers)
    previous_status = {m['id']: m['status'] for m in response.json()['data']}

    print('Начинаем мониторинг изменений статуса...')

    while True:
        try:
            response = requests.get('https://mycompany.slyfox.su/v1/monitors', headers=headers)
            current_status = {m['id']: m['status'] for m in response.json()['data']}

            for monitor_id, status in current_status.items():
                if monitor_id in previous_status and previous_status[monitor_id] != status:
                    monitor_info = next(m for m in response.json()['data'] if m['id'] == monitor_id)
                    message = f"""
🔔 *Изменение статуса монитора*

📌 Название: {monitor_info['friendly_name']}
🌐 URL: {monitor_info['url']}
📊 Новый статус: {'✅ Онлайн' if status == 'online' else '❌ Офлайн'}
⏰ Время: {monitor_info['last_check']}
                    """
                    notifier.send_message(message)

            previous_status = current_status.copy()
            time.sleep(300)

        except Exception as e:
            print(f'Ошибка мониторинга: {e}')
            time.sleep(300)

# monitor_status_changes('YOUR_API_KEY', 'YOUR_BOT_TOKEN', 'YOUR_CHAT_ID')