Day 29: Bugsink – Self-hosted Error Tracking – 7 Days of Docker

23. April 2025

Development / Deployment / Docker / Hosting

.SHARE

For the past several years, my error tracking journey has involved multiple platforms. Initially, I utilized Sentry in both their hosted service and self-hosted configurations.

However, as Sentry’s pricing structure became prohibitively expensive and maintaining the self-hosted version proved resource-intensive.

I transitioned to Glitchtip (Article about setting it up) approximately four years ago. Glitchtip has performed reliably overall, with only occasional REDIS-related crashes disrupting service.

Recently, I’ve become aware of Bugsink, an emerging competitor in the self-hosted error tracking space. They also offer a hosted service, at competitive prices. First impressions are solid, slim solution that concentrates on bug tracking … thank you!

Prerequisites for self-hosting

A server with Docker and Docker Compose installed
Basic knowledge of Docker and Docker Compose
Terminal access to your server
Sufficient disk space for the MySQL database and event storage

Step 1: Get the Docker Compose Configuration

1. Create a directory for your Bugsink installation:


mkdir bugsink && cd bugsink

mkdir bugsink && cd bugsink

2. Download the sample Docker Compose file from the Bugsink repository:


curl -O https://raw.githubusercontent.com/bugsink/bugsink/main/compose-sample.yaml

curl -O https://raw.githubusercontent.com/bugsink/bugsink/main/compose-sample.yaml

3. Rename it to compose.yaml:


mv compose-sample.yaml compose.yaml

mv compose-sample.yaml compose.yaml

Step 2: Configure Your compose.yaml File

Edit the compose.yaml file to customize your installation. Here’s the default configuration:


services:
  mysql:
    image: mysql:latest
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: change_your_passwords_for_real_usage # TODO: Change this
      MYSQL_DATABASE: bugsink
    volumes:
      - my-datavolume:/var/lib/mysql
    healthcheck:
      test: ["CMD-SHELL", "exit | mysql -h localhost -P 3306 -u root -p$$MYSQL_ROOT_PASSWORD" ]
      interval: 1s
      timeout: 20s
      retries: 30
  
  web:
    image: bugsink/bugsink
    depends_on:
      mysql:
        condition: service_healthy
    restart: unless-stopped
    ports:
      - "8000:8000"
    environment:
      SECRET_KEY: django-insecure-RMLYThim9NybWgXiUGat32Aa0Qbgqscf4NPDQuZO2glcZPOiXn # Change this (and remove django-insecure prefix)
      CREATE_SUPERUSER: admin:admin # Change this (or remove it and execute 'createsuperuser' against the running container)
      PORT: 8000
      DATABASE_URL: mysql://root:change_your_passwords_for_real_usage@mysql:3306/bugsink
    healthcheck:
      test: ["CMD-SHELL", "python -c 'import requests; requests.get(\"http://localhost:8000/\").raise_for_status()'"]
      interval: 5s
      timeout: 20s
      retries: 10

volumes:
  my-datavolume:

services:

mysql:

image: mysql:latest

restart: unless-stopped

environment:

MYSQL_ROOT_PASSWORD: change_your_passwords_for_real_usage # TODO: Change this

MYSQL_DATABASE: bugsink

volumes:

- my-datavolume:/var/lib/mysql

healthcheck:

test: ["CMD-SHELL", "exit | mysql -h localhost -P 3306 -u root -p$$MYSQL_ROOT_PASSWORD" ]

interval: 1s

timeout: 20s

retries: 30

web:

image: bugsink/bugsink

depends_on:

mysql:

condition: service_healthy

restart: unless-stopped

ports:

- "8000:8000"

environment:

SECRET_KEY: django-insecure-RMLYThim9NybWgXiUGat32Aa0Qbgqscf4NPDQuZO2glcZPOiXn # Change this (and remove django-insecure prefix)

CREATE_SUPERUSER: admin:admin # Change this (or remove it and execute 'createsuperuser' against the running container)

PORT: 8000

DATABASE_URL: mysql://root:change_your_passwords_for_real_usage@mysql:3306/bugsink

healthcheck:

test: ["CMD-SHELL", "python -c 'import requests; requests.get(\"http://localhost:8000/\").raise_for_status()'"]

interval: 5s

timeout: 20s

retries: 10

volumes:

my-datavolume:

Important Security Settings to Change:

MYSQL_ROOT_PASSWORD: Change to a secure password
SECRET_KEY: Generate a secure key (e.g., openssl rand -base64 50) and remove the “django-insecure” prefix
CREATE_SUPERUSER: Change to your desired admin username and password
Update DATABASE_URL to match your MySQL password

Step 3: Environment Variables by Group

Core Settings

Variable	Description	Default	Example
`SECRET_KEY`	Secret key for cryptographic signing	–	`openssl rand -base64 50`
`PORT`	Port the webserver listens on	`8000`	`8000`
`CREATE_SUPERUSER`	Create admin user on startup	–	`admin:securepassword`
`BASE_URL`	URL where Bugsink is hosted	`http://localhost:8000`	`https://bugsink.yourdomain.com`
`SITE_TITLE`	Custom site title	`Bugsink`	`Company Bugsink`
`TIME_ZONE`	Default timezone	`UTC`	`America/New_York`

Database Settings

Variable	Description	Default	Example
`DATABASE_URL`	Database connection string	–	`mysql://user:password@mysql:3306/bugsink`
`MYSQL_ROOT_PASSWORD`	MySQL root password	–	`your-secure-password`
`MYSQL_DATABASE`	MySQL database name	`bugsink`	`bugsink`

Proxy and HTTPS Settings

Variable	Description	Default	Example
`BEHIND_HTTPS_PROXY`	Whether Bugsink is behind HTTPS proxy	`False`	`True`
`SECURE_PROXY_SSL_HEADER`	SSL header configuration	–	`('HTTP_X_FORWARDED_PROTO', 'https')`
`SESSION_COOKIE_SECURE`	Use secure cookies	`False`	`True`
`CSRF_COOKIE_SECURE`	Use secure CSRF cookies	`False`	`True`
`USE_X_REAL_IP`	Use X-Real-IP header	`False`	`True`

Email Settings

Variable	Description	Default	Example
`EMAIL_HOST`	SMTP host	–	`smtp.example.com`
`EMAIL_HOST_USER`	SMTP username	–	`user@example.com`
`EMAIL_HOST_PASSWORD`	SMTP password	–	`your-password`
`EMAIL_PORT`	SMTP port	`587`	`587`
`EMAIL_USE_TLS`	Use TLS for email	`True`	`True`
`EMAIL_USE_SSL`	Use SSL for email	`False`	`False`
`DEFAULT_FROM_EMAIL`	Default sender email	`Bugsink`	`Bugsink`

User and Team Settings

Variable	Description	Default	Example
`SINGLE_USER`	Disable multi-user functionality	`False`	`True`
`SINGLE_TEAM`	Disable multi-team functionality	`False`	`True`
`USER_REGISTRATION`	Control user registration	–	`CB_ADMINS`
`USER_REGISTRATION_VERIFY_EMAIL`	Require email verification	`False`	`True`
`TEAM_CREATION`	Control team creation	–	`CB_ADMINS`

Rate Limiting and Resource Settings

Variable	Description	Default	Example
`MAX_EVENT_SIZE`	Maximum event size	`1048576` (1MB)	`2097152` (2MB)
`MAX_ENVELOPE_SIZE`	Maximum envelope size	`104857600` (100MB)	`104857600`
`MAX_EVENTS_PER_PROJECT_PER_5_MINUTES`	5-minute rate limit	`1000`	`5000`
`MAX_EVENTS_PER_PROJECT_PER_HOUR`	Hourly rate limit	`5000`	`20000`

Event Storage Settings

Variable	Description	Default	Example
`FILE_EVENT_STORAGE_PATH`	Path for file event storage	–	`/app/event_storage`
`FILE_EVENT_STORAGE_USE_FOR_WRITE`	Enable file storage	`False`	`True`

Background Worker Settings

Variable	Description	Default	Example
`DIGEST_IMMEDIATELY`	Process events immediately	`True`	`False`
`TASK_ALWAYS_EAGER`	Run tasks inline	`True`	`False`
`SNAPPEA_NUM_WORKERS`	Number of worker threads	`2`	`4`

Step 4: Start the Bugsink Server

1. Launch the services:


docker compose up -d

docker compose up -d

2. Check if the services are running:


docker compose ps

docker compose ps

3. Check the logs for any issues:


docker compose logs

docker compose logs

4. Access your Bugsink instance at http://your-server-ip:8000/ and log in with the credentials specified in CREATE_SUPERUSER.

Step 5: Setting Up a Reverse Proxy for Production (Recommended)

For production environments, it’s strongly recommended to use a reverse proxy like Nginx. Here’s a basic Nginx configuration:


server {
    listen 80;
    server_name bugsink.yourdomain.com;
    
    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {

listen 80;

server_name bugsink.yourdomain.com;

location / {

proxy_pass http://localhost:8000;

proxy_set_header Host $host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_set_header X-Forwarded-Proto $scheme;

}

With SSL (recommended):


server {
    listen 443 ssl;
    server_name bugsink.yourdomain.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location / {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {
    listen 80;
    server_name bugsink.yourdomain.com;
    return 301 https://$host$request_uri;
}

server {

listen 443 ssl;

server_name bugsink.yourdomain.com;

ssl_certificate /path/to/cert.pem;

ssl_certificate_key /path/to/key.pem;

location / {

proxy_pass http://localhost:8000;

proxy_set_header Host $host;

proxy_set_header X-Real-IP $remote_addr;

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_set_header X-Forwarded-Proto $scheme;

}

server {

listen 80;

server_name bugsink.yourdomain.com;

return 301 https://$host$request_uri;

}

Remember to set BEHIND_HTTPS_PROXY: "True" in your Docker Compose configuration when using HTTPS.

Step 6: Event Storage Configuration (Optional)

By default, Bugsink stores events in the database. For larger installations, you might want to use file-based storage:


environment:
  # Existing variables...
  
  # File event storage
  FILE_EVENT_STORAGE_PATH: "/app/event_storage"
  FILE_EVENT_STORAGE_USE_FOR_WRITE: "True"

environment:

# Existing variables...

# File event storage

FILE_EVENT_STORAGE_PATH: "/app/event_storage"

FILE_EVENT_STORAGE_USE_FOR_WRITE: "True"

Add a volume mount to persist the event storage:


volumes:
  - event-storage:/app/event_storage

# And add this to the volumes section
volumes:
  my-datavolume:
  event-storage:

volumes:

- event-storage:/app/event_storage

# And add this to the volumes section

volumes:

my-datavolume:

event-storage:

Useful Links

Comparison: Sentry vs GlitchTip vs Bugsink

Overview

Platform	Description	Philosophy	Target Audience
Sentry	Comprehensive monitoring platform with robust features	Full-featured monitoring solution beyond error tracking	From small teams to large enterprises
GlitchTip	Open-source alternative compatible with Sentry SDKs	Simpler, more affordable Sentry alternative	Teams seeking cost-effective monitoring
Bugsink	Focused error tracking with emphasis on self-hosting	Streamlined, specialized error tracking	Developers prioritizing simplicity, control, and predictable costs

Feature Comparison

Feature	Sentry	GlitchTip	Bugsink
Error Tracking	Yes (Advanced)	Yes (Compatible with Sentry)	Yes (Core focus)
Performance Monitoring	Yes (Comprehensive)	Yes (Basic)	No (Not a focus)
Uptime Monitoring	Yes	Yes	No
Session Replay	Yes	No	No
Profiling	Yes (UI & Continuous)	No	No
Cron Monitoring	Yes	No	No
Custom Dashboards	Yes (Business+)	No	No
Unlimited Projects	Yes	Yes	Yes
Unlimited Team Members	Yes (Team+)	Yes	Yes (Self-hosted)

Deployment Options

Platform	Self-Hosted	Cloud-Hosted	Installation Complexity
Sentry	Yes (Discouraged)	Yes (Primary)	Complex (Difficult & Demanding)
GlitchTip	Yes	Yes	Moderate ( Pretty Easy)
Bugsink	Yes (Primary)	Yes (Managed)	Simple (30-second claim)

Pricing

Platform	Free Tier	Paid Plans	Pricing Model
Sentry	Developer: 1 user, 5K errors	• Team: $26/mo (50K errors) • Business: $80/mo (50K errors) • Enterprise: Custom	Managed: Event-based Self-hosed: Free
GlitchTip	1K events/month	• Small: $15/mo (100K events) • Medium: $50/mo (500K events) • Large: $250/mo (3M events)	Managed:Event-based Self-hosted: Free
Bugsink	• Self-hosted: Free • Single Developer: Free (5K events)	• Team: €15/mo (50K events) • Enterprise: Custom	Self-hosted: Free Managed: User-based+events License Info

Technical Aspects

Aspect	Sentry	GlitchTip	Bugsink
SDK Compatibility	Native SDKs for multiple languages	Uses Sentry’s open-source SDKs	Compatible with Sentry SDKs
Scalability	Enterprise-grade	Limited information	Claims to handle millions of events on minimal hardware
Open-Source Status	Open-source core with commercial offerings	Fully open-source	Source-available proprietary
Data Control	Limited in cloud version	Better in self-hosted	Full control with self-hosted

Which Platform Is Right For You?

Sentry is best for:

Teams needing comprehensive monitoring beyond error tracking
Organizations requiring enterprise-grade features
Users who prefer a mature, fully-featured cloud solution

GlitchTip is best for:

Teams looking for a more affordable Sentry alternative
Organizations that value open-source software
Users who want unlimited team members at a lower price point

Bugsink is best for:

Developers focused specifically on error tracking
Teams wanting complete data control through self-hosting
Organizations seeking simple setup and predictable costs
Users who want to avoid event-based pricing models for self-hosted deployments

Conclusion

When choosing an error monitoring platform, consider your specific needs, team size, budget, and technical requirements. Sentry provides a robust, feature-rich solution suitable for enterprise environments. GlitchTip offers a cost-effective, open-source alternative with balanced capabilities. Bugsink focuses on simplicity and self-hosting with predictable costs. Also see my comments at the start of the article ;)

The ideal platform depends on your priorities: comprehensive features (Sentry), cost-effectiveness with decent features (GlitchTip), or simplicity with full control (Bugsink). Each has its strengths, making them suitable for different development environments and organizational requirements.

Sources

Let’s Talk!

Looking for a reliable partner to bring your project to the next level? Whether it’s development, design, security, or ongoing support—I’d love to chat and see how I can help.

Get in touch,
and let’s create something amazing together!

Above the Fold: A Critical Web Design Concept Across All Devices

Design / Development / Search Engines

Ever hear web designers obsess about “above the fold” content? This term isn’t just designer jargon—it’s a fundamental concept that can make or break your website’s effectiveness. Let’s dive into what it means, why it matters, and how it works differently across the devices we use every day. What Exactly Is “Above the Fold”? The […]

VPN Showdown 2025: The Definitive Guide to Privacy, Streaming & Speed

Development / Deployment / Enviroment / Security

Look, these days a solid VPN isn’t just nice to have—it’s practically essential. Whether you want to keep your browsing habits private, access that show that’s somehow available everywhere except your country, or just avoid getting hacked on sketchy coffee shop Wi-Fi, picking the right VPN makes all the difference. We’ve spent hours testing and […]

Smart Refresh: Make Your Raspberry Pi Display Update Only When Content Changes

Development / Content Creation / Digital Kiosk / Digital Signage / Hardware

Need your Raspberry Pi to only update its display when content actually changes? Tired of constant refreshes wasting bandwidth and causing annoying flickers? I’ve got you covered! This guide walks through three practical solutions – from simple HTTP caching to real-time WebSockets – that will make your Pi display work smarter, not harder. Let’s dive […]

Alexander

I am a full-stack developer. My expertise include:

Server, Network and Hosting Environments
Data Modeling / Import / Export
Business Logic
API Layer / Action layer / MVC
User Interfaces
User Experience
Understand what the customer and the business needs

I have a deep passion for programming, design, and server architecture—each of these fuels my creativity, and I wouldn’t feel complete without them.

With a broad range of interests, I’m always exploring new technologies and expanding my knowledge wherever needed. The tech world evolves rapidly, and I love staying ahead by embracing the latest innovations.

Beyond technology, I value peace and surround myself with like-minded individuals.

I firmly believe in the principle: Help others, and help will find its way back to you when you need it.

Day 29: Bugsink – Self-hosted Error Tracking – 7 Days of Docker

Table of Contents

Prerequisites for self-hosting

Step 1: Get the Docker Compose Configuration

Step 2: Configure Your compose.yaml File

Important Security Settings to Change:

Step 3: Environment Variables by Group

Core Settings

Database Settings

Proxy and HTTPS Settings

Email Settings

User and Team Settings

Rate Limiting and Resource Settings

Event Storage Settings

Background Worker Settings

Step 4: Start the Bugsink Server

Step 5: Setting Up a Reverse Proxy for Production (Recommended)

Step 6: Event Storage Configuration (Optional)

Useful Links

Comparison: Sentry vs GlitchTip vs Bugsink

Overview

Feature Comparison

Deployment Options

Pricing

Technical Aspects

Which Platform Is Right For You?

Sentry is best for:

GlitchTip is best for:

Bugsink is best for:

Conclusion

Sources

RELATED POSTS

Above the Fold: A Critical Web Design Concept Across All Devices

VPN Showdown 2025: The Definitive Guide to Privacy, Streaming & Speed

Smart Refresh: Make Your Raspberry Pi Display Update Only When Content Changes

Alexander

DISCOVER.

.highlights

.highlights