Peekaping

https://docs.peekaping.com
Admin
Peekaping is a modern, self-hosted uptime monitoring solution built with Go and React, offering...
Tokens:15,572
Snippets:213
Trust Score:5.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install asdf Plugins Manually

Source: https://docs.peekaping.com/development

Solution for `make setup` failures. Manually add the necessary asdf plugins (golang, nodejs, pnpm) and then run `asdf install`.

```bash
# Solution: Install asdf plugins manually
asdf plugin add golang
asdf plugin add nodejs
asdf plugin add pnpm
asdf install

```

--------------------------------

### Run Project Setup with asdf

Source: https://docs.peekaping.com/development

Use the Makefile to automatically install the correct versions of Go and Node.js using asdf. This is the recommended method for tool management.

```bash
# Run the setup target
make setup

```

--------------------------------

### Example Usage of Universal Wrapper Script

Source: https://docs.peekaping.com/development

Demonstrates how to use the universal wrapper script (`scripts/tool.sh`) to execute Go tests, install pnpm dependencies, and check the Node.js version.

```bash
# Using the universal wrapper
./scripts/tool.sh go test ./src/...
./scripts/tool.sh pnpm install
./scripts/tool.sh node --version

```

--------------------------------

### Check Manual Tool Installations

Source: https://docs.peekaping.com/development

Verify that Node.js, Go, and pnpm are installed with the correct versions after manual installation.

```bash
node -v
go version
pnpm --version

```

--------------------------------

### Start Development Servers with pnpm

Source: https://docs.peekaping.com/development

Alternative method to start the documentation server in watch mode using pnpm directly.

```bash
# Option 2: Using pnpm directly
pnpm run dev docs:watch

```

--------------------------------

### Start Development Servers with Makefile

Source: https://docs.peekaping.com/development

Recommended method to run the full stack (backend, frontend, docs) in development mode using the project's Makefile.

```bash
# Option 1: Using the Makefile (recommended)
make dev

```

--------------------------------

### Install Project Dependencies

Source: https://docs.peekaping.com/development

Install all project dependencies for the web and server applications using the provided Makefile target.

```bash
make install

```

--------------------------------

### Run Development Database with Docker Compose

Source: https://docs.peekaping.com/development

Use Docker Compose to run a local database for development. This example shows how to start a PostgreSQL instance.

```bash
docker compose -f docker-compose.postgres.yml up -d

```

--------------------------------

### Install WAHA Server using Docker

Source: https://docs.peekaping.com/notifications/whatsapp

Run the WAHA server locally using Docker. Ensure the WAHA server is accessible via the specified port.

```bash
docker run -d \
  --name waha \
  -p 3000:3000 \
  devlikeapro/waha:latest  

```

--------------------------------

### Copy and Edit Environment File

Source: https://docs.peekaping.com/development

Copy the production environment example file to `.env` and then edit it with your preferred settings. This file contains common variables for the application.

```bash
cp .env.prod.example .env
# Edit .env with your preferred editor

```

--------------------------------

### Peekaping Project Structure

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Defines the basic directory structure for a Peekaping installation in microservice mode, including essential configuration files.

```text
peekaping/  
├── .env  
├── docker-compose.yml  
└── nginx.conf  

```

--------------------------------

### Peekaping .env Configuration

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Example `.env` file for configuring Peekaping, including database credentials, server settings, and application parameters. Ensure sensitive information like passwords is kept secure.

```dotenv
# Database Configuration  
DB_USER=root  
DB_PASS=your-secure-password-here  
DB_NAME=peekaping  
DB_HOST=database  
DB_PORT=5432  
DB_TYPE=postgres  
  
# Server Configuration  
SERVER_PORT=8034  
CLIENT_URL="http://localhost:8383"  
  
# Application Settings  
MODE=prod  
TZ="America/New_York"  
  
# JWT settings are automatically managed in the database  
# Default settings are initialized on first startup:  
# - Access token expiration: 15 minutes  
# - Refresh token expiration: 720 hours (30 days)  
# - Secret keys are automatically generated securely  

```

--------------------------------

### Reshim asdf Tools

Source: https://docs.peekaping.com/development

Solution for tools not being found after asdf installation. Run `asdf reshim` for the specific tools to update their shims.

```bash
# Solution: Reshim asdf
asdf reshim golang
asdf reshim nodejs
asdf reshim pnpm

```

--------------------------------

### Common Environment Variables

Source: https://docs.peekaping.com/development

Example of common environment variables used for configuring the Peekaping application, including database connection details and server ports.

```dotenv
DB_USER=root
DB_PASSWORD=your-secure-password
DB_NAME=peekaping
DB_HOST=localhost
DB_PORT=6001
DB_TYPE=mongo # or postgres | mysql | sqlite
SERVER_PORT=8034
CLIENT_URL="http://localhost:5173"
MODE=prod
TZ="America/New_York"

# JWT settings are now automatically managed in the database.
# Default settings are initialized on first startup:
# - Access token expiration: 15 minutes
# - Refresh token expiration: 720 hours (30 days)
# - Secret keys are automatically generated securely

```

--------------------------------

### Docker Compose Configuration for Migrate Service

Source: https://docs.peekaping.com/architecture/migrate

Example Docker Compose configuration for running the migrate service. It builds the binary, copies migration files, runs the migrate command, and exits upon completion.

```yaml
migrate:
  build:
    context: ./apps/server
    dockerfile: infra/Dockerfile.migrate
  restart: "no"  # Run once and exit
  env_file:
    - .env
  depends_on:
    database:
      condition: service_healthy
  networks:
    - appnet
```

--------------------------------

### Health Check Response Example

Source: https://docs.peekaping.com/architecture/api-server

Example of a successful response from the health check endpoint, indicating the server is running.

```json
{
  "status": "ok",
  "timestamp": "2024-01-01T00:00:00Z"
}
```

--------------------------------

### Docker Compose Management Commands

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Commands to navigate to the project directory, start all services in detached mode, check service status, and view logs.

```bash
# Navigate to your project directory
cd peekaping

# Start all services
docker compose up -d

# Check status
docker compose ps

# View logs
docker compose logs -f

```

--------------------------------

### Example WhatsApp Message Template

Source: https://docs.peekaping.com/notifications/whatsapp

Define a custom message template for WhatsApp notifications. This template uses Liquid syntax to dynamically insert alert details.

```plaintext
🚨 Peekaping Alert  
  
Monitor: {{ monitor.name }}  
Status: {{ status }}  
Message: {{ msg }}  
  
Time: {{ heartbeat.created_at }}  


```

--------------------------------

### Pull Latest Docker Images

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

Use this command to fetch the latest versions of your Docker images defined in your docker-compose file. Ensure you have Docker Compose installed and configured.

```bash
docker compose pull
```

--------------------------------

### Peekaping .env Configuration File

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

Sets up environment variables for Peekaping, including database credentials, server port, and client URL.

```dotenv
# Database Configuration  
DB_USER=root  
DB_PASS=your-secure-password-here  
DB_NAME=peekaping  
DB_HOST=database  
DB_PORT=27017  
DB_TYPE=mongo  
  
# Server Configuration  
SERVER_PORT=8034  
CLIENT_URL="http://localhost:8383"  
  
# Application Settings  
MODE=prod  
TZ="America/New_York"  
  
# JWT settings are automatically managed in the database  
# Default settings are initialized on first startup:  
# - Access token expiration: 15 minutes  
# - Refresh token expiration: 720 hours (30 days)  
# - Secret keys are automatically generated securely  

```

--------------------------------

### Run Peekaping Monolithic Docker Image

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

Launches the Peekaping bundle with MongoDB in a single Docker container. Mounts local data and exposes the application port.

```bash
docker run -d --restart=always \
  -p 8383:8383 \
  -e DB_NAME=peekaping \
  -e DB_USER=peekaping \
  -e DB_PASS=secure_test_password_123 \
  -v $(pwd)/.data/mongodb:/data/db \
  --name peekaping \
  0xfurai/peekaping-bundle-mongo:latest  

```

--------------------------------

### Run Peekaping in Monolithic Mode

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Launches Peekaping with all microservices in a single Docker container. Mounts a local directory for SQLite data persistence and maps the container's port to the host.

```bash
docker run -d --restart=always \
  -p 8383:8383 \
  -e DB_NAME=/app/data/peekaping.db \
  -v $(pwd)/.data/sqlite:/app/data \
  --name peekaping \
  0xfurai/peekaping-bundle-sqlite:latest  

```

--------------------------------

### Run Peekaping in Monolithic Mode

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Launches Peekaping with all components in a single Docker container, including PostgreSQL. Mounts a volume for persistent PostgreSQL data and maps the application port.

```bash
docker run -d --restart=always \
  -p 8383:8383 \
  -e DB_NAME=peekaping \
  -e DB_USER=peekaping \
  -e DB_PASS=secure_test_password_123 \
  -v $(pwd)/.data/postgres:/var/lib/postgresql/data \
  --name peekaping \
  0xfurai/peekaping-bundle-postgres:latest  

```

--------------------------------

### Clone Peekaping Repository

Source: https://docs.peekaping.com/development

Clone the Peekaping repository from GitHub and navigate into the project directory.

```bash
git clone https://github.com/0xfurai/peekaping.git
cd peekaping

```

--------------------------------

### Docker Compose Configuration for Peekaping

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Defines the services, networks, and volumes for self-hosting Peekaping. Includes configurations for PostgreSQL, Redis, migration, API, producer, worker, ingester, web, and Nginx gateway.

```yaml
networks:
  appnet:

services:
  database:
    image: postgres:17
    restart: unless-stopped
    env_file:
      - .env
    environment:
      POSTGRES_USER: ${DB_USER:-postgres}
      POSTGRES_PASSWORD: ${DB_PASS:-password}
      POSTGRES_DB: ${DB_NAME:-peekaping}
    volumes:
      - ./.data/postgres:/var/lib/postgresql/data
    networks:
      - appnet
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "pg_isready -U ${DB_USER:-postgres} -d ${DB_NAME:-peekaping}",
        ]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

  redis:
    image: redis:7
    restart: unless-stopped
    networks:
      - appnet
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

  migrate:
    image: 0xfurai/peekaping-migrate:latest
    restart: "no"
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
    networks:
      - appnet

  api:
    image: 0xfurai/peekaping-api:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "wget -qO - http://localhost:8034/api/v1/health || exit 1",
        ]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

  producer:
    image: 0xfurai/peekaping-producer:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet

  worker:
    image: 0xfurai/peekaping-worker:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      redis:
        condition: service_healthy
    networks:
      - appnet

  ingester:
    image: 0xfurai/peekaping-ingester:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet

  web:
    image: 0xfurai/peekaping-web:latest
    depends_on:
      api:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

  gateway:
    image: nginx:latest
    ports:
      - "8383:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      api:
        condition: service_healthy
      web:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

```

--------------------------------

### Peekaping .env Configuration

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Sets up environment variables for Peekaping, including database credentials, server port, and client URL. Sensitive information like JWT secrets are managed automatically.

```dotenv
# Database Configuration  
DB_USER=root  
DB_PASS=your-secure-password-here  
DB_NAME=/app/data/peekaping.db  
DB_TYPE=sqlite  
  
# Server Configuration  
SERVER_PORT=8034  
CLIENT_URL="http://localhost:8383"  
  
# Application Settings  
MODE=prod  
TZ="America/New_York"  
  
# JWT settings are automatically managed in the database  
# Default settings are initialized on first startup:  
# - Access token expiration: 15 minutes  
# - Refresh token expiration: 720 hours (30 days)  
# - Secret keys are automatically generated securely  

```

--------------------------------

### Check and Set asdf Tool Versions

Source: https://docs.peekaping.com/development

Troubleshoot issues with wrong tool versions being used by asdf. Check the currently active versions and set the correct local versions for Go and Node.js.

```bash
# Solution: Check which version is active
asdf current

# Set the correct version
asdf local golang 1.24.1
asdf local nodejs 20.18.0

```

--------------------------------

### Access Swagger/OpenAPI Documentation

Source: https://docs.peekaping.com/architecture/api-server

Access the auto-generated API documentation via the Swagger UI. Ensure the server is running on the configured port.

```http
http://localhost:8034/swagger/index.html
```

--------------------------------

### MongoDB Volume Configuration Options

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

Illustrates two methods for configuring persistent storage for MongoDB within Docker Compose: local folder mount and named volumes.

```yaml
volumes:
  - ./.data/mongodb:/data/db

```

```yaml
volumes:
  - mongodb_data:/data/db

volumes:
  mongodb_data:

```

--------------------------------

### Create New Transactional SQL Migration

Source: https://docs.peekaping.com/architecture/migrate

Generates a new SQL migration file with a .tx.up.sql and .tx.down.sql suffix, intended for transactional changes.

```bash
go run cmd/bun/main.go db create_tx_sql add_new_feature
```

--------------------------------

### Apply All Pending Migrations

Source: https://docs.peekaping.com/architecture/migrate

Use this command to apply all migrations that have not yet been applied to the database.

```bash
go run cmd/bun/main.go db migrate
```

--------------------------------

### Updating Peekaping Docker Images

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Commands to pull the latest Docker images, restart services with the new images, and clean up old, unused images.

```bash
# Pull latest images
docker compose pull

# Restart with new images
docker compose up -d

# Clean up old images
docker image prune

```

--------------------------------

### Docker Compose Configuration for Peekaping

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

Defines the services, networks, and health checks for self-hosting Peekaping. This includes MongoDB, Redis, API, producer, worker, ingester, web, and Nginx gateway services.

```yaml
networks:
  appnet:
  
services:
  database:
    image: mongo:7
    restart: unless-stopped
    env_file:
      - .env
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${DB_USER}
      MONGO_INITDB_ROOT_PASSWORD: ${DB_PASS}
      MONGO_INITDB_DATABASE: ${DB_NAME}
    volumes:
      - ./.data/mongodb:/data/db
    networks:
      - appnet
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s
  
  redis:
    image: redis:7
    restart: unless-stopped
    networks:
      - appnet
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s
  
  api:
    image: 0xfurai/peekaping-api:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test: ["CMD-SHELL", "wget -qO - http://localhost:8034/api/v1/health || exit 1"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s
  
  producer:
    image: 0xfurai/peekaping-producer:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet
  
  worker:
    image: 0xfurai/peekaping-worker:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      redis:
        condition: service_healthy
    networks:
      - appnet
  
ingester:
    image: 0xfurai/peekaping-ingester:latest
    restart: unless-stopped
    env_file:
      - .env
    depends_on:
      database:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - appnet
  
  web:
    image: 0xfurai/peekaping-web:latest
    depends_on:
      api:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s
  
  gateway:
    image: nginx:latest
    ports:
      - "8383:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      api:
        condition: service_healthy
      web:
        condition: service_healthy
    networks:
      - appnet
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 2s
      retries: 5
      start_period: 5s

```

--------------------------------

### Add Custom Caddyfile to Docker Volume

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Specifies how to mount a custom Caddyfile into the Docker container for custom Caddy configurations. This is an addition to the `docker run` command.

```bash
-v ./custom-Caddyfile:/etc/caddy/Caddyfile:ro  

```

--------------------------------

### Peekaping Docker Compose Configuration

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Defines the services, networks, and volumes for a multi-container Peekaping deployment using Docker Compose. Includes health checks for various services.

```yaml
networks:  
  appnet:  
  
services:  
  redis:  
    image: redis:7  
    restart: unless-stopped  
    networks:  
      - appnet  
    healthcheck:  
      test: ["CMD", "redis-cli", "ping"]  
      interval: 30s  
      timeout: 2s  
      retries: 5  
      start_period: 5s  
  
  migrate:  
    image: 0xfurai/peekaping-migrate:latest  
    restart: "no"  
    env_file:  
      - .env  
    volumes:  
      - ./.data/sqlite:/app/data  
  
  api:  
    image: 0xfurai/peekaping-api:latest  
    restart: unless-stopped  
    env_file:  
      - .env  
    volumes:  
      - ./.data/sqlite:/app/data  
    depends_on:  
      redis:  
        condition: service_started  
      migrate:  
        condition: service_completed_successfully  
    networks:  
      - appnet  
    healthcheck:  
      test:  
        [  
          "CMD-SHELL",  
          "wget -qO - http://localhost:8034/api/v1/health || exit 1",  
        ]  
      interval: 30s  
      timeout: 2s  
      retries: 5  
      start_period: 5s  
  
  producer:  
    image: 0xfurai/peekaping-producer:latest  
    restart: unless-stopped  
    env_file:  
      - .env  
    volumes:  
      - ./.data/sqlite:/app/data  
    depends_on:  
      redis:  
        condition: service_healthy  
      migrate:  
        condition: service_completed_successfully  
    networks:  
      - appnet  
  
  worker:  
    image: 0xfurai/peekaping-worker:latest  
    restart: unless-stopped  
    env_file:  
      - .env  
    depends_on:  
      redis:  
        condition: service_healthy  
    networks:  
      - appnet  
  
  ingester:  
    image: 0xfurai/peekaping-ingester:latest  
    restart: unless-stopped  
    env_file:  
      - .env  
    volumes:  
      - ./.data/sqlite:/app/data  
    depends_on:  
      redis:  
        condition: service_started  
      migrate:  
        condition: service_completed_successfully  
    networks:  
      - appnet  
  
  web:  
    image: 0xfurai/peekaping-web:latest  
    depends_on:  
      api:  
        condition: service_healthy  
    networks:  
      - appnet  
    healthcheck:  
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]  
      interval: 30s  
      timeout: 2s  
      retries: 5  
      start_period: 5s  
  
  gateway:  
    image: nginx:latest  
    ports:  
      - "8383:80"  
    volumes:  
      - ./nginx.conf:/etc/nginx/nginx.conf:ro  
    depends_on:  
      api:  
        condition: service_healthy  
      web:  
        condition: service_healthy  
    networks:  
      - appnet  
    healthcheck:  
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]  
      interval: 30s  
      timeout: 2s  
      retries: 5  
      start_period: 5s  

```

--------------------------------

### Check Migration Status

Source: https://docs.peekaping.com/architecture/migrate

Displays the current status of all database migrations.

```bash
go run cmd/bun/main.go db status
```

--------------------------------

### View Peekaping Server Logs

Source: https://docs.peekaping.com/notifications/whatsapp

Access Peekaping server logs to debug issues related to WhatsApp notification delivery. These logs provide details on WAHA API requests and responses.

```bash
docker logs peekaping-server-1  

```

--------------------------------

### Badge Customization Options

Source: https://docs.peekaping.com/badges

Details on how to customize the appearance and text of Peekaping badges using query parameters.

```APIDOC
## Customization Parameters for All Badges

### Style Options
- `style` (string) - Optional - Badge visual style. Possible values: `flat`, `flat-square`, `plastic`, `for-the-badge`, `social`.

### Color Options
- `color` (string) - Optional - Hex color code to override the value background color (e.g., `4c1`, `007ec6`).
- `labelColor` (string) - Optional - Hex color code to override the label background color (e.g., `555`, `333`).

### Text Customization
- `label` (string) - Optional - Custom text for the badge label.
- `labelPrefix` (string) - Optional - Text to prepend to the label.
- `labelSuffix` (string) - Optional - Text to append to the label.
- `prefix` (string) - Optional - Text to prepend to the badge value.
- `suffix` (string) - Optional - Text to append to the badge value.

### Status Badge Specific Options
- `upLabel` (string) - Optional - Custom text for the 'Up' status.
- `downLabel` (string) - Optional - Custom text for the 'Down' status.
- `upColor` (string) - Optional - Hex color code for the 'Up' status.
- `downColor` (string) - Optional - Hex color code for the 'Down' status.

### Certificate Badge Specific Options
- `warnDays` (integer) - Optional - Days threshold for warning color (default: 14).
- `downDays` (integer) - Optional - Days threshold for critical color (default: 7).
```

--------------------------------

### Update Peekaping Application

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Commands to update your Peekaping application to the latest version. This involves pulling new Docker images, restarting the containers, and removing unused images.

```bash
# Pull latest images
docker compose pull
```

```bash
# Restart with new images
docker compose up -d
```

```bash
# Clean up old images
docker image prune
```

--------------------------------

### Markdown Badge Usage

Source: https://docs.peekaping.com/badges

Display various Peekaping badges in Markdown format, including API status, uptime, and response time.

```Markdown
![API Status](https://your-peekaping-instance.com/api/v1/badge/monitor-123/status)
![Uptime](https://your-peekaping-instance.com/api/v1/badge/monitor-123/uptime)
![Response Time](https://your-peekaping-instance.com/api/v1/badge/monitor-123/ping)
```

--------------------------------

### Migration File Naming Convention

Source: https://docs.peekaping.com/architecture/migrate

Defines the naming convention for migration files, ensuring ordered execution and transactional integrity.

```text
YYYYMMDDHHMMSS_description.tx.{up|down}.sql
```

--------------------------------

### Restart Services with New Images

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

After pulling new images, use this command to stop, remove, and recreate your containers with the updated images. The '-d' flag runs containers in detached mode.

```bash
docker compose up -d
```

--------------------------------

### Monitor Response Time Badge

Source: https://docs.peekaping.com/badges

Show the response time of a monitor with this badge. Customize the style using the `style` parameter.

```html
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/ping?style=flat-square" alt="Response Time" />
```

--------------------------------

### Nginx Configuration for Reverse Proxy

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Sets up Nginx as a reverse proxy for Peekaping API and web services. It routes API calls to the server, handles socket.io connections, and serves the static SPA.

```nginx
events {}
http {
  upstream server  { server server:8034; }
  upstream web { server web:80; }

  server {
    listen 80;

    # Pure API calls
    location /api/ {
      proxy_pass         http://server;
      proxy_set_header   Host $host;
      proxy_set_header   X-Real-IP $remote_addr;
    }

    # socket.io
    location /socket.io/ {
      proxy_pass http://server;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
    }

    # Everything else → static SPA
    location / {
      proxy_pass http://web;
    }
  }
}

```

--------------------------------

### Monitor Uptime Badge

Source: https://docs.peekaping.com/badges

Display the uptime percentage for a monitor using this badge. The `style=flat-square` parameter is optional for customization.

```html
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/uptime?style=flat-square" alt="Uptime" />
```

--------------------------------

### Connect to WebSocket Endpoint

Source: https://docs.peekaping.com/architecture/api-server

Establish a WebSocket connection for real-time updates. This endpoint is used for bidirectional communication with web clients.

```websocket
ws://localhost:8034/api/v1/ws
```

--------------------------------

### Uptime Badge

Source: https://docs.peekaping.com/badges

Displays the uptime percentage for a specific time period. Supports default 24 hours or custom durations like 30 or 90 days.

```APIDOC
## GET /api/v1/badge/{monitorId}/uptime
## GET /api/v1/badge/{monitorId}/uptime/{duration}

### Description
Retrieves the uptime percentage of a monitor as an SVG badge for a specified duration.

### Endpoint
`/api/v1/badge/{monitorId}/uptime`
`/api/v1/badge/{monitorId}/uptime/{duration}`

### Parameters
#### Path Parameters
- **monitorId** (string) - Required - The unique identifier of the monitor.
- **duration** (integer) - Optional - The time period in hours for which to calculate uptime. Defaults to 24 hours. Supported values: 24 (24 hours), 720 (30 days), 2160 (90 days).

### Response
#### Success Response (200)
- SVG image representing the monitor's uptime percentage.
```

--------------------------------

### Status Badge URL

Source: https://docs.peekaping.com/badges

Use this URL to display the current operational status of a monitor. Possible values include Up, Down, Pending, Maintenance, and Paused.

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/status
```

--------------------------------

### Docker Compose Volume Configuration (Local Mount)

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Configure a local folder mount in docker-compose.yml to persist SQLite data in a directory within your project.

```yaml
volumes:
  - ./.data/sqlite:/app/data

```

--------------------------------

### Ping Badge

Source: https://docs.peekaping.com/badges

Shows the average response time for a monitor. Supports default 24 hours or custom durations like 30 or 90 days.

```APIDOC
## GET /api/v1/badge/{monitorId}/ping
## GET /api/v1/badge/{monitorId}/ping/{duration}

### Description
Retrieves the average response time of a monitor as an SVG badge for a specified duration.

### Endpoint
`/api/v1/badge/{monitorId}/ping`
`/api/v1/badge/{monitorId}/ping/{duration}`

### Parameters
#### Path Parameters
- **monitorId** (string) - Required - The unique identifier of the monitor.
- **duration** (integer) - Optional - The time period in hours for which to calculate the average response time. Defaults to 24 hours. Supported values: 24 (24 hours), 720 (30 days), 2160 (90 days).

### Response
#### Success Response (200)
- SVG image representing the monitor's average response time.
```

--------------------------------

### Local Folder Mount for PostgreSQL Data

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Use this volume configuration to store PostgreSQL data in a local folder within your project directory. This is the recommended approach for persistent storage.

```yaml
volumes:
  - ./.data/postgres:/var/lib/postgresql/data
```

--------------------------------

### Docker Compose Volume Configuration (Named Volume)

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Configure a named volume in docker-compose.yml for persistent SQLite data and define the volume at the bottom of the file.

```yaml
volumes:
  - sqlite_data:/app/data

volumes:
  sqlite_data:

```

--------------------------------

### Custom Labels and Thresholds

Source: https://docs.peekaping.com/badges

Customize badge labels, colors, and thresholds for status, certificate expiry, and response time badges.

```HTML
<!-- Custom status labels -->
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/status?upLabel=Online&downLabel=Offline" alt="API Status">
  
<!-- Custom certificate warning threshold -->
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/cert-exp?warnDays=30&downDays=14" alt="SSL Certificate">
  
<!-- Custom prefix/suffix -->
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/ping?prefix=~&suffix=ms&label=Latency" alt="API Latency">
```

--------------------------------

### Response Time Badge URL

Source: https://docs.peekaping.com/badges

Shows the most recent response time measurement for your monitor.

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/response
```

--------------------------------

### Ping Badge URL

Source: https://docs.peekaping.com/badges

Shows the average response time for your monitor. The duration options are the same as the uptime badge.

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/ping
```

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/ping/{duration}
```

--------------------------------

### Uptime Badge URL

Source: https://docs.peekaping.com/badges

Displays the uptime percentage for a specified time period. The duration can be set to the last 24 hours (default), 30 days (720 hours), or 90 days (2160 hours).

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/uptime
```

```URL
https://your-peekaping-instance.com/api/v1/badge/{monitorId}/uptime/{duration}
```

--------------------------------

### API Key Authentication Header

Source: https://docs.peekaping.com/architecture/api-server

Use this header format for programmatic API access with an API key.

```http
X-API-Key: pk_<key>
```

--------------------------------

### Response Time Badge

Source: https://docs.peekaping.com/badges

Shows the most recent response time measurement for a monitor.

```APIDOC
## GET /api/v1/badge/{monitorId}/response

### Description
Retrieves the most recent response time measurement for a monitor as an SVG badge.

### Endpoint
`/api/v1/badge/{monitorId}/response`

### Parameters
#### Path Parameters
- **monitorId** (string) - Required - The unique identifier of the monitor.

### Response
#### Success Response (200)
- SVG image representing the monitor's most recent response time.
```

--------------------------------

### Embed Custom Styled Uptime Badge

Source: https://docs.peekaping.com/badges

Embed an uptime badge with custom styling (flat-square) and color (brightgreen) for a 30-day period.

```HTML
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/uptime/720?style=flat-square&color=brightgreen" alt="30-day Uptime">
```

--------------------------------

### Named Volume for PostgreSQL Data

Source: https://docs.peekaping.com/self-hosting/docker-with-postgres

Configure a named volume for PostgreSQL data storage. This requires defining the volume at the bottom of your docker-compose.yml file.

```yaml
volumes:
  - postgres_data:/var/lib/postgresql/data
```

```yaml
volumes:
  postgres_data:
```

--------------------------------

### Add asdf to Shell Configuration

Source: https://docs.peekaping.com/development

Solution for 'asdf: command not found' error. Ensure asdf is added to your PATH by sourcing it in your shell configuration file (e.g., .zshrc or .bashrc).

```bash
# Solution: Make sure asdf is in your PATH
echo '. "$HOME/.asdf/asdf.sh"' >> ~/.zshrc  # or ~/.bashrc
source ~/.zshrc  # or ~/.bashrc

```

--------------------------------

### Website Integration Badges

Source: https://docs.peekaping.com/badges

Embed multiple badges within a div for a comprehensive service health overview. Adjust the `src` URLs to match your monitor IDs and desired metrics.

```html
<div class="service-status">
  <h3>Service Health</h3>
  <p>
    <img src="https://your-peekaping-instance.com/api/v1/badge/api-monitor/status" alt="API Status" />
    <img src="https://your-peekaping-instance.com/api/v1/badge/api-monitor/uptime/720" alt="30-day Uptime" />
    <img src="https://your-peekaping-instance.com/api/v1/badge/api-monitor/ping/720" alt="Response Time" />
  </p>
</div>
```

--------------------------------

### Status Badge

Source: https://docs.peekaping.com/badges

Displays the current operational status of a monitor. Possible values include Up, Down, Pending, Maintenance, and Paused.

```APIDOC
## GET /api/v1/badge/{monitorId}/status

### Description
Retrieves the current operational status of a monitor as an SVG badge.

### Endpoint
`/api/v1/badge/{monitorId}/status`

### Parameters
#### Path Parameters
- **monitorId** (string) - Required - The unique identifier of the monitor.

### Response
#### Success Response (200)
- SVG image representing the monitor's status (e.g., Up, Down, Pending, Maintenance, Paused).
```

--------------------------------

### Producer Shutdown Logs

Source: https://docs.peekaping.com/architecture/producer

Logs indicating the producer is stopping gracefully upon receiving a shutdown signal.

```log
INFO Shutdown signal received, stopping producer...  
INFO Producer stopped gracefully  

```

--------------------------------

### JWT Authentication Header

Source: https://docs.peekaping.com/architecture/api-server

Use this header format for authenticating web application users with a JWT token.

```http
Authorization: Bearer <token>
```

--------------------------------

### SSL Certificate Expiry Badge

Source: https://docs.peekaping.com/badges

Track SSL certificate expiry dates with this badge. Ensure the monitor ID corresponds to a service with SSL monitoring enabled.

```html
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/cert-exp?style=flat-square" alt="SSL Cert" />
```

--------------------------------

### Status Dashboard Badges

Source: https://docs.peekaping.com/badges

Organize service status badges within a grid for a clear dashboard view. Each service can have its own set of status and uptime badges.

```html
<div class="status-grid">
  <div class="service">
    <h4>Web API</h4>
    <img src="https://your-peekaping-instance.com/api/v1/badge/web-api/status" />
    <img src="https://your-peekaping-instance.com/api/v1/badge/web-api/uptime" />
  </div>
  <div class="service">
    <h4>Database</h4>
    <img src="https://your-peekaping-instance.com/api/v1/badge/database/status" />
    <img src="https://your-peekaping-instance.com/api/v1/badge/database/ping" />
  </div>
</div>
```

--------------------------------

### Monitor Status Badge

Source: https://docs.peekaping.com/badges

Embed this badge to show the current status of a specific monitor. Ensure the monitor ID is correct and public badges are enabled.

```html
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/status?style=flat-square" alt="Service Status" />
```

--------------------------------

### Embed Basic Status Badge

Source: https://docs.peekaping.com/badges

Embed a basic status badge directly into HTML using the `<img>` tag.

```HTML
<img src="https://your-peekaping-instance.com/api/v1/badge/monitor-123/status" alt="Service Status">
```

--------------------------------

### Nginx Reverse Proxy Configuration

Source: https://docs.peekaping.com/self-hosting/docker-with-sqlite

Configure Nginx to proxy API requests, socket.io connections, and static assets to the appropriate backend services.

```nginx
events {}
http {
  upstream server  { server server:8034; }
  upstream web { server web:80; }
  
  server {
    listen 80;

    # Pure API calls
    location /api/ {
      proxy_pass         http://server;
      proxy_set_header   Host $host;
      proxy_set_header   X-Real-IP $remote_addr;
    }

    # socket.io
    location /socket.io/ {
      proxy_pass http://server;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";
    }

    # Everything else → static SPA
    location / {
      proxy_pass http://web;
    }
  }
}

```

--------------------------------

### Certificate Expiry Badge

Source: https://docs.peekaping.com/badges

Displays SSL certificate expiration information for HTTPS monitors, with color coding indicating urgency.

```APIDOC
## GET /api/v1/badge/{monitorId}/cert-exp

### Description
Retrieves SSL certificate expiration information for an HTTPS monitor as an SVG badge. The badge color indicates the expiration proximity.

### Endpoint
`/api/v1/badge/{monitorId}/cert-exp`

### Parameters
#### Path Parameters
- **monitorId** (string) - Required - The unique identifier of the monitor.

### Query Parameters
#### Certificate Badge Options
- **warnDays** (integer) - Optional - The number of days before expiration to trigger a warning color. Defaults to 14.
- **downDays** (integer) - Optional - The number of days before expiration to trigger a critical (red) color. Defaults to 7.

### Response
#### Success Response (200)
- SVG image representing the SSL certificate expiration status.
```

--------------------------------

### Rollback Last Migration Group

Source: https://docs.peekaping.com/architecture/migrate

Executes a rollback for the most recently applied group of migrations.

```bash
go run cmd/bun/main.go db rollback
```

--------------------------------

### Clean Up Unused Docker Images

Source: https://docs.peekaping.com/self-hosting/docker-with-mongo

This command removes dangling images (images not associated with any container) to free up disk space. Use with caution as it permanently deletes images.

```bash
docker image prune
```

--------------------------------

### Health Check Endpoint

Source: https://docs.peekaping.com/architecture/api-server

Call this endpoint to verify the API server's operational status. It returns the current status and a timestamp.

```http
GET /api/v1/health
```
Tokens:
Raw