# /etc/systemd/system/trading-strategy@.service
[Unit]
Description=Trading strategy %i
After=network-online.target postgresql.service
Wants=network-online.target

[Service]
Type=notify
ExecStart=/opt/trading/venv/bin/python /opt/trading/strategies/%i/main.py
WorkingDirectory=/opt/trading/strategies/%i
Restart=always
RestartSec=5
WatchdogSec=60

# Resource limits
MemoryMax=4G
CPUQuota=200%
TasksMax=100

# Logging
StandardOutput=journal
StandardError=journal
SyslogIdentifier=trading-%i

# Security
User=trading
NoNewPrivileges=true
ProtectSystem=strict
ReadWritePaths=/opt/trading/data /var/lib/postgresql

[Install]
WantedBy=multi-user.target

SELECT time_bucket('1 day', time) AS day,
       FIRST(open), MAX(high), MIN(low), LAST(close), SUM(volume)
FROM trades GROUP BY day;

from prometheus_client import CollectorRegistry, Gauge, start_http_server

registry = CollectorRegistry()
equity = Gauge('trading_equity', 'Account equity', registry=registry)
trades_open = Gauge('trading_open_trades', 'Num open trades', registry=registry)
drawdown = Gauge('trading_drawdown_pct', 'Current drawdown %', registry=registry)

# In your bot loop:
equity.set(account_balance)
trades_open.set(len(open_positions))
drawdown.set(current_drawdown)

start_http_server(9090, registry=registry)

CREATE TABLE ticks (
    time TIMESTAMPTZ NOT NULL,
    symbol TEXT NOT NULL,
    price DOUBLE PRECISION,
    volume BIGINT
);
SELECT create_hypertable('ticks', 'time');

CREATE MATERIALIZED VIEW ohlcv_1h WITH (timescaledb.continuous) AS
SELECT
    time_bucket('1 hour', time) AS bucket,
    symbol,
    FIRST(price, time) AS open,
    MAX(price) AS high,
    MIN(price) AS low,
    LAST(price, time) AS close,
    SUM(volume) AS volume
FROM ticks
GROUP BY bucket, symbol;

pg_probackup init -B /mnt/storage/backups/pg_probackup
pg_probackup backup -B /mnt/storage/backups/pg_probackup -b DELTA -d trading_db

rclone sync /mnt/storage/backups/pg_probackup hetzner-s3:trading-backups/ --transfers 4

# /etc/systemd/system/trading-backup.timer
[Unit]
Description=Daily trading database backup

[Timer]
OnCalendar=*-*-* 03:00:00
Persistent=true

[Install]
WantedBy=timers.target

groups:
  - name: trading
    rules:
      - alert: StrategyNoTrades
        expr: rate(trading_trades_total[1h]) == 0
        for: 2h
        annotations:
          summary: "Strategy {{ $labels.strategy }} not trading for 2h"

      - alert: MaxDrawdown
        expr: trading_drawdown_pct > 15
        for: 5m
        annotations:
          summary: "Drawdown {{ $value }}% > threshold"

      - alert: DataFeedStale
        expr: time() - trading_last_tick_timestamp > 300
        for: 1m
        annotations:
          summary: "Data feed stale for {{ $labels.symbol }}"

      - alert: BrokerDisconnected
        expr: trading_broker_connected == 0
        for: 2m
        annotations:
          summary: "Broker {{ $labels.broker }} disconnected"

sudo pacman -S loki promtail
# Promtail scrapes journald for trading-* units
systemctl start loki promtail

import structlog

structlog.configure(processors=[structlog.processors.JSONRenderer()])
logger = structlog.get_logger()

logger.info("trade_executed",
            symbol="BTCUSD",
            side="buy",
            price=42000,
            volume=1.5,
            order_id="ord_123",
            strategy="mean_reversion")

# /etc/systemd/system/trading-ingest@.timer
[Unit]
Description=Market data ingestion for %i

[Timer]
OnBootSec=2min
OnUnitActiveSec=1min
Persistent=true

[Install]
WantedBy=timers.target

# /etc/systemd/system/trading-ingest@.service
[Unit]
Description=Ingest market data for %i
After=network-online.target

[Service]
Type=oneshot
ExecStart=/opt/trading/venv/bin/python /opt/trading/scripts/ingest.py --symbol %i --interval 1m
StandardOutput=journal
StandardError=journal

def reconcile_positions():
    internal = query_trades_today()   # From your DB
    broker = get_broker_positions()    # Via API

    mismatches = []
    for symbol in set(internal.keys() | broker.keys()):
        if internal.get(symbol, 0) != broker.get(symbol, 0):
            mismatches.append({
                'symbol': symbol,
                'internal': internal[symbol],
                'broker': broker[symbol],
            })

    if mismatches:
        alert("reconciliation_failed", mismatches=mismatches)