Skip to content
Klutch.sh Docs

Deploying Bugzilla

Bugzilla is a powerful open source bug tracking system developed by an active group of volunteers in the Mozilla community and used by thousands of projects and companies worldwide. Built with Perl and designed for reliability and scalability, Bugzilla provides comprehensive bug tracking capabilities including advanced search, product and component management, milestone tracking, custom fields, email integration, and REST API support. Whether you’re managing software development for a small team, coordinating large enterprise projects, tracking open source project issues, managing customer support tickets, or organizing quality assurance workflows, Bugzilla offers the flexibility and power needed to streamline your development process and improve product quality.

Why Bugzilla?

Bugzilla stands out as the premier choice for bug tracking with exceptional features:

  • Advanced Search: Powerful search and filtering capabilities
  • Products and Components: Organize bugs by product and component
  • Milestones: Track progress on releases and versions
  • Custom Fields: Create custom fields for your workflow
  • Email Integration: Automatic email notifications
  • Attachments: Store attachments with bugs
  • Keywords: Categorize and tag bugs
  • Workflows: Configure custom bug status workflows
  • Dependencies: Track bug relationships and dependencies
  • Flags and Reviews: Flag bugs for review or approval
  • Time Tracking: Track time spent on bugs (optional)
  • Voting System: Users can vote on bug importance
  • Whine System: Automated email reports
  • REST API: Full REST API for integrations
  • JSONRPC API: JSONRPC support for integrations
  • Role-Based Access: Control user permissions
  • Email Gateway: Accept bugs via email
  • Bulk Operations: Edit multiple bugs at once
  • Reports and Charts: Generate reports and charts
  • Scalable: Handles millions of bugs
  • Open Source: MPL 2.0 licensed with active community

Bugzilla is ideal for software development teams managing bug tracking, open source projects organizing community contributions, quality assurance teams managing testing, enterprise organizations tracking issues, and distributed teams coordinating development. With persistent storage on Klutch.sh, your bug tracking system is always available, secure, and scalable.

Prerequisites

Before deploying Bugzilla, ensure you have:

  • A Klutch.sh account
  • A GitHub repository with your Bugzilla deployment configuration
  • Basic familiarity with Docker and Git
  • MySQL database for bug data storage (MySQL 5.7.17+)
  • Sufficient storage for attachments and data (typically 10-100GB)
  • SMTP credentials for email notifications (recommended)
  • Custom domain for your bug tracker (recommended)
  • Understanding of bug tracking workflows
  • Time for initial configuration

Important Considerations

Deploying Bugzilla

  1. Create a New Project

    Log in to your Klutch.sh dashboard and create a new project for your Bugzilla bug tracking system.

  2. Prepare Your Repository

    Create a GitHub repository with the following structure for your Bugzilla deployment:

    bugzilla-deploy/
    ├─ Dockerfile
    ├─ localconfig
    ├─ .env.example
    ├─ entrypoint.sh
    ├─ .gitignore
    └─ README.md

    Here’s a Dockerfile for Bugzilla:

    FROM perl:5.36-slim
    

    WORKDIR /var/www/bugzilla
    

    # Install system dependencies
    RUN apt-get update && apt-get install -y \
        curl \
        git \
        wget \
        mysql-client \
        apache2 \
        apache2-dev \
        build-essential \
        libexpat-dev \
        libcairo-dev \
        libpng-dev \
        && a2enmod cgi \
        && a2enmod rewrite \
        && a2enmod headers \
        && rm -rf /var/lib/apt/lists/*
    

    # Clone Bugzilla repository
    RUN git clone --depth 1 https://github.com/bugzilla/bugzilla.git /tmp/bugzilla && \
        cp -r /tmp/bugzilla/* . && \
        rm -rf /tmp/bugzilla
    

    # Install Perl dependencies
    RUN cpan -i $(cat /var/www/bugzilla/cpanfile | grep '^\s*"' | sed 's/.*"\([^"]*\)".*/\1/' | sort | uniq | tr '\n' ' ') 2>/dev/null || true
    

    # Create necessary directories
    RUN mkdir -p /var/www/bugzilla/data \
        /var/www/bugzilla/attachments \
        /var/www/bugzilla/logs \
        /var/www/bugzilla/graphs \
        && chown -R www-data:www-data /var/www/bugzilla \
        && chmod -R 755 /var/www/bugzilla
    

    # Copy configuration file
    COPY localconfig /var/www/bugzilla/localconfig
    

    # Copy entrypoint script
    COPY entrypoint.sh /
    RUN chmod +x /entrypoint.sh
    

    # Configure Apache
    RUN echo "ServerName localhost" >> /etc/apache2/apache2.conf && \
        echo "<Directory /var/www/bugzilla>" >> /etc/apache2/sites-available/000-default.conf && \
        echo "AllowOverride All" >> /etc/apache2/sites-available/000-default.conf && \
        echo "Require all granted" >> /etc/apache2/sites-available/000-default.conf && \
        echo "</Directory>" >> /etc/apache2/sites-available/000-default.conf
    

    # Expose port
    EXPOSE 80
    

    # Health check
    HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
      CMD curl -f http://localhost/ || exit 1
    

    # Run entrypoint
    ENTRYPOINT ["/entrypoint.sh"]
    CMD ["apache2-foreground"]

    Create a localconfig file:

    # Bugzilla Configuration File
    

    # Database settings
    $db_driver = 'mysql';
    $db_host = $ENV{'DATABASE_HOST'} || 'localhost';
    $db_name = $ENV{'DATABASE_NAME'} || 'bugzilla';
    $db_user = $ENV{'DATABASE_USER'} || 'bugzilla';
    $db_pass = $ENV{'DATABASE_PASSWORD'} || 'password';
    $db_port = $ENV{'DATABASE_PORT'} || '3306';
    

    # Web server settings
    $webservergroup = 'www-data';
    $cgi_url_base = $ENV{'CGI_URL_BASE'} || '/';
    

    # Email settings
    $mail_delivery_method = $ENV{'MAIL_DELIVERY_METHOD'} || 'SMTP';
    $mailfrom = $ENV{'MAIL_FROM'} || 'bugzilla@localhost';
    $smtp_server = $ENV{'SMTP_HOST'} || 'localhost';
    $smtp_port = $ENV{'SMTP_PORT'} || 25;
    $smtp_username = $ENV{'SMTP_USER'} || '';
    $smtp_password = $ENV{'SMTP_PASS'} || '';
    

    # Site settings
    $urlbase = $ENV{'URL_BASE'} || 'http://localhost/';
    $siteroot = $ENV{'SITE_ROOT'} || '/';
    $shortname = $ENV{'SITE_NAME'} || 'Bugzilla';
    

    # Admin settings
    $admin_account = $ENV{'ADMIN_EMAIL'} || 'admin@localhost';
    $admin_name = $ENV{'ADMIN_NAME'} || 'Administrator';
    $admin_pass = $ENV{'ADMIN_PASSWORD'} || 'password';
    

    # Security settings
    $use_https = 1;
    $ssl_redirect = 1;
    $require_https = 1;
    

    # Session settings
    $rememberlogin = 'on';
    $session_age = 604800;
    

    1;

    Create an entrypoint.sh file:

    #!/bin/bash
    

    set -e
    

    echo "Initializing Bugzilla..."
    

    # Create necessary directories
    mkdir -p /var/www/bugzilla/data \
             /var/www/bugzilla/attachments \
             /var/www/bugzilla/logs \
             /var/www/bugzilla/graphs
    

    # Set proper permissions
    chown -R www-data:www-data /var/www/bugzilla
    chmod -R 755 /var/www/bugzilla
    

    # Wait for MySQL to be ready
    echo "Waiting for MySQL..."
    MAX_RETRIES=30
    RETRY_COUNT=0
    

    until mysqladmin ping -h"$DATABASE_HOST" -u"$DATABASE_USER" -p"$DATABASE_PASSWORD" --silent 2>/dev/null; do
      RETRY_COUNT=$((RETRY_COUNT + 1))
      if [ $RETRY_COUNT -gt $MAX_RETRIES ]; then
        echo "MySQL not available after $MAX_RETRIES retries"
        exit 1
      fi
      echo "MySQL is unavailable, sleeping... (attempt $RETRY_COUNT/$MAX_RETRIES)"
      sleep 2
    done
    

    echo "MySQL is up!"
    

    # Run Bugzilla setup
    echo "Running Bugzilla checksetup..."
    cd /var/www/bugzilla
    perl checksetup.pl --no-sanity-check 2>&1 || true
    

    # Run sanity check
    echo "Running Bugzilla sanity check..."
    perl sanitycheck.pl 2>&1 || true
    

    echo "Bugzilla is starting..."
    exec "$@"

    Create a .env.example file:

    Terminal window
    # Bugzilla Configuration
    DATABASE_HOST=mysql.internal
    DATABASE_NAME=bugzilla
    DATABASE_USER=bugzilla
    DATABASE_PASSWORD=secure_password
    DATABASE_PORT=3306
    

    # Bugzilla Settings
    SITE_NAME=Bugzilla
    URL_BASE=https://bugs.yourdomain.com/
    CGI_URL_BASE=/
    

    # Admin Account
    ADMIN_EMAIL=admin@yourdomain.com
    ADMIN_NAME=Administrator
    ADMIN_PASSWORD=secure_admin_password
    

    # Email Configuration
    MAIL_DELIVERY_METHOD=SMTP
    MAIL_FROM=bugzilla@yourdomain.com
    SMTP_HOST=smtp.gmail.com
    SMTP_PORT=587
    SMTP_USER=your-email@gmail.com
    SMTP_PASS=your-app-password

    Create a .gitignore file:

    localconfig
    .env
    data/
    attachments/
    logs/
    graphs/
    *.log
    .DS_Store
    .idea/
    *.swp
    *.swo
    /data/
    /attachments/
    /logs/
    /graphs/
    /template_cache/

    Commit and push to your GitHub repository:

    Terminal window
    git init
    git add .
    git commit -m "Initial Bugzilla bug tracking deployment"
    git remote add origin https://github.com/yourusername/bugzilla-deploy.git
    git push -u origin main

  3. Create a New App

    In the Klutch.sh dashboard:

    • Click “Create New App”
    • Select your GitHub repository containing the Dockerfile
    • Choose the branch (typically main or master)
    • Klutch.sh will automatically detect the Dockerfile in the root directory

  4. Configure Environment Variables

    Set up these essential environment variables in your Klutch.sh dashboard:

    VariableDescriptionExample
    DATABASE_HOSTMySQL hostmysql.internal
    DATABASE_NAMEDatabase namebugzilla
    DATABASE_USERDatabase userbugzilla
    DATABASE_PASSWORDDatabase passwordsecure_password
    DATABASE_PORTDatabase port3306
    SITE_NAMEBugzilla site nameBugzilla
    URL_BASEBase URLhttps://bugs.yourdomain.com/
    ADMIN_EMAILAdmin emailadmin@yourdomain.com
    ADMIN_NAMEAdmin nameAdministrator
    ADMIN_PASSWORDAdmin passwordsecure_password
    SMTP_HOSTSMTP serversmtp.gmail.com
    SMTP_PORTSMTP port587
    SMTP_USERSMTP usernameemail@gmail.com
    SMTP_PASSSMTP passwordapp_password
    MAIL_FROMFrom email addressbugzilla@yourdomain.com

  5. Configure Persistent Storage

    Bugzilla requires persistent storage for attachments and data. Add persistent volumes:

    Mount PathDescriptionRecommended Size
    /var/www/bugzilla/attachmentsBug attachments and files50GB
    /var/www/bugzilla/dataBugzilla data20GB

    In the Klutch.sh dashboard:

    • Navigate to your app settings
    • Go to the “Volumes” section
    • Click “Add Volume” for each mount path
    • Set mount paths and sizes as specified above
    • Ensure attachment volume is sized for file storage

  6. Set Network Configuration

    Configure your app’s network settings:

    • Select traffic type: HTTP
    • Recommended internal port: 80 (Apache default)
    • Klutch.sh will handle HTTPS termination via reverse proxy
    • Application will be accessible via your custom domain

  7. Configure Custom Domain

    Bugzilla benefits from a custom domain:

    • Navigate to your app’s “Domains” section in Klutch.sh
    • Add custom domain (e.g., bugs.yourdomain.com)
    • Configure DNS with CNAME record pointing to your Klutch.sh app
    • Update URL_BASE environment variable
    • Klutch.sh will automatically provision SSL certificate
    • Wait for DNS propagation (typically 5-15 minutes)

  8. Deploy Your App

    • Review all settings and environment variables carefully
    • Verify database connection string is correct
    • Verify SMTP configuration is complete
    • Ensure custom domain is configured
    • Verify persistent volumes are properly configured
    • Click “Deploy”
    • Klutch.sh will build the Docker image and start your Bugzilla instance
    • Wait for deployment to complete (typically 15-25 minutes)
    • Access your Bugzilla at your configured domain
    • Log in with admin credentials
    • Complete Bugzilla configuration wizard

Initial Setup and Configuration

After deployment completes, configure your bug tracking system.

Accessing Bugzilla

Navigate to your domain: https://bugs.yourdomain.com

Access administration: https://bugs.yourdomain.com/admin.cgi

Log in with your admin credentials set during deployment.

Bugzilla Configuration Wizard

Complete initial setup:

  1. Go to Administration
  2. Parameters section guides configuration
  3. Configure site preferences:
    • Site name and description
    • User authentication settings
    • Email settings
    • Time zone
  4. Set up default products and components
  5. Create initial user groups
  6. Configure workflow

Creating Products

Set up products to track:

  1. Go to Admin → Products
  2. Click “Add Product”
  3. Enter product details:
    • Product name
    • Description
    • Classification
    • Version numbering
  4. Click “Create”
  5. Now add components to product

Creating Components

Organize bugs within products:

  1. Go to Admin → Products
  2. Select product
  3. Click “Add Component”
  4. Enter component details:
    • Component name
    • Description
    • Default owner
    • Default QA contact
  5. Click “Add Component”
  6. Create additional components as needed

Setting Up Custom Fields

Add custom fields to bugs:

  1. Go to Admin → Custom Fields
  2. Click “Add a Custom Field”
  3. Configure field:
    • Field name and description
    • Field type (text, checkbox, dropdown, etc.)
    • Required or optional
    • Visibility and editability
  4. Save field
  5. Field appears in bug forms

Configuring Bug Workflow

Define bug status workflow:

  1. Go to Admin → Workflow
  2. View current workflow states
  3. Define transitions:
    • NEW → ASSIGNED
    • ASSIGNED → RESOLVED
    • RESOLVED → CLOSED
  4. Set resolution types
  5. Define workflow rules
  6. Save workflow

Setting Up User Groups

Organize team members:

  1. Go to Admin → Groups
  2. Click “Add a new group”
  3. Create groups:
    • Developer group
    • QA group
    • Manager group
    • Other roles as needed
  4. Set group permissions
  5. Assign users to groups

Managing User Accounts

Create user accounts:

  1. Go to Admin → Users
  2. Click “Add a new user”
  3. Enter user details:
    • Email address
    • Real name
    • Disable/Enable account
  4. Set user group membership
  5. Send welcome email to user
  6. User receives login credentials

Configuring Email Notifications

Set up email preferences:

  1. Go to Admin → Email
  2. Configure email settings:
    • From address
    • Reply-to address
    • Email delivery method
  3. Test email sending
  4. Configure whine reports
  5. Set email notification frequency

Setting Up Email Gateway

Accept bugs via email:

  1. Configure email_in.pl script
  2. Set up email forwarding to Bugzilla
  3. Define email parsing rules
  4. Map email fields to bug fields
  5. Test email submission
  6. Monitor email queue

Creating Bug Aliases

Enable short names for bugs:

  1. Go to Admin → Parameters
  2. Find “usebugaliases” setting
  3. Enable bug aliases
  4. Users can set custom names for bugs
  5. Easier to remember than bug numbers

Configuring Search and Reports

Set up search capabilities:

  1. Go to Search
  2. Configure search filters
  3. Save frequent searches
  4. Set up saved queries
  5. Create custom reports
  6. Schedule report generation

Setting Up Keywords

Categorize bugs with keywords:

  1. Go to Admin → Keywords
  2. Click “Add a new keyword”
  3. Create keywords:
    • Performance
    • Security
    • Crash
    • Feature-request
    • Other project-specific keywords
  4. Users can apply multiple keywords
  5. Filter bugs by keyword

Enabling Time Tracking

Track time spent on bugs (optional):

  1. Go to Admin → Parameters
  2. Find “timetrackinggroup” setting
  3. Enable time tracking
  4. Set estimated vs actual time
  5. Generate time reports
  6. Track team productivity

Environment Variable Examples

Basic Configuration

Terminal window
DATABASE_HOST=mysql.internal
DATABASE_NAME=bugzilla
DATABASE_USER=bugzilla
DATABASE_PASSWORD=secure_password
SITE_NAME=Bugzilla
URL_BASE=https://bugs.yourdomain.com/
ADMIN_EMAIL=admin@yourdomain.com
ADMIN_PASSWORD=secure_password

Complete Production Configuration

Terminal window
# Database Configuration
DATABASE_HOST=mysql.internal
DATABASE_NAME=bugzilla
DATABASE_USER=bugzilla
DATABASE_PASSWORD=very_secure_database_password_32_chars
DATABASE_PORT=3306


# Site Configuration
SITE_NAME=Professional Bug Tracking
URL_BASE=https://bugs.yourdomain.com/
CGI_URL_BASE=/
SITE_ROOT=/


# Admin Account
ADMIN_EMAIL=admin@yourdomain.com
ADMIN_NAME=System Administrator
ADMIN_PASSWORD=very_secure_admin_password_32_chars


# Email Configuration
MAIL_DELIVERY_METHOD=SMTP
MAIL_FROM=bugzilla@yourdomain.com
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=bugzilla-noreply@yourdomain.com
SMTP_PASS=app-specific-google-password


# Security Settings
USE_HTTPS=1
SSL_REDIRECT=1
REQUIRE_HTTPS=1


# Session Settings
REMEMBER_LOGIN=on
SESSION_AGE=604800

Sample Code and Getting Started

Perl - Bug Management Integration

#!/usr/bin/perl


# Bugzilla Bug Management Integration


use strict;
use warnings;
use lib qw(/var/www/bugzilla);


use Bugzilla;
use Bugzilla::Bug;
use Bugzilla::User;
use Bugzilla::Product;
use Bugzilla::Component;


package BugzillaManager;


# Create new bug
sub create_bug {
    my ($self, %params) = @_;


    Bugzilla->login(LOGIN_REQUIRED);


    my $product = Bugzilla::Product->check({ name => $params{product} });
    my $component = Bugzilla::Component->check({
        product => $product,
        name => $params{component}
    });


    my $bug = Bugzilla::Bug->create({
        product => $product,
        component => $component,
        short_desc => $params{summary},
        comment => $params{description},
        assigned_to => $params{assigned_to} || 'default@yourdomain.com',
        priority => $params{priority} || 'P3',
        severity => $params{severity} || 'normal',
        keywords => $params{keywords} || [],
    });


    return {
        id => $bug->id,
        summary => $bug->short_desc,
        created => $bug->creation_time,
    };
}


# Get bug details
sub get_bug {
    my ($self, $bug_id) = @_;


    my $bug = Bugzilla::Bug->check($bug_id);


    return {
        id => $bug->id,
        summary => $bug->short_desc,
        description => $bug->comments->[0]->{body},
        status => $bug->status->name,
        resolution => $bug->resolution,
        assigned_to => $bug->assigned_to->login,
        component => $bug->component->name,
        product => $bug->product->name,
        created => $bug->creation_time,
        modified => $bug->last_change_time,
        priority => $bug->priority,
        severity => $bug->severity,
    };
}


# Add comment to bug
sub add_comment {
    my ($self, $bug_id, $comment) = @_;


    my $bug = Bugzilla::Bug->check($bug_id);


    $bug->add_comment($comment);
    $bug->update();


    return { success => 1, comment_added => $comment };
}


# Change bug status
sub change_status {
    my ($self, $bug_id, $new_status) = @_;


    my $bug = Bugzilla::Bug->check($bug_id);


    $bug->set_status($new_status);
    $bug->update();


    return {
        id => $bug->id,
        new_status => $bug->status->name,
    };
}


# Assign bug to user
sub assign_bug {
    my ($self, $bug_id, $email) = @_;


    my $bug = Bugzilla::Bug->check($bug_id);
    my $user = Bugzilla::User->check($email);


    $bug->set_assigned_to($user);
    $bug->update();


    return {
        id => $bug->id,
        assigned_to => $user->login,
    };
}


# Search bugs
sub search_bugs {
    my ($self, %criteria) = @_;


    my @bugs = Bugzilla::Bug->match({
        product => $criteria{product},
        component => $criteria{component},
        status => $criteria{status},
        keywords => $criteria{keywords},
        limit => $criteria{limit} || 50,
    });


    return [map { {
        id => $_->id,
        summary => $_->short_desc,
        status => $_->status->name,
    } } @bugs];
}


1;

Bash - Backup and Database Management Script

#!/bin/bash


# Bugzilla Backup and Maintenance Script
BACKUP_DIR="/backups/bugzilla"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30


# Configuration
DB_HOST="${DATABASE_HOST}"
DB_USER="${DATABASE_USER}"
DB_PASSWORD="${DATABASE_PASSWORD}"
DB_NAME="${DATABASE_NAME}"


# Create backup directory
mkdir -p $BACKUP_DIR


echo "Starting Bugzilla backup..."


# Backup MySQL database
echo "Backing up MySQL database..."
mysqldump -h"$DB_HOST" -u"$DB_USER" -p"$DB_PASSWORD" "$DB_NAME" | gzip > "$BACKUP_DIR/bugzilla_db_$TIMESTAMP.sql.gz"


# Backup attachments
echo "Backing up attachments..."
tar -czf "$BACKUP_DIR/bugzilla_attachments_$TIMESTAMP.tar.gz" \
  /var/www/bugzilla/attachments 2>/dev/null || true


# Backup data directory
echo "Backing up data..."
tar -czf "$BACKUP_DIR/bugzilla_data_$TIMESTAMP.tar.gz" \
  /var/www/bugzilla/data 2>/dev/null || true


# Backup configuration
echo "Backing up configuration..."
tar -czf "$BACKUP_DIR/bugzilla_config_$TIMESTAMP.tar.gz" \
  /var/www/bugzilla/localconfig 2>/dev/null || true


# Cleanup old backups
echo "Cleaning up old backups..."
find $BACKUP_DIR -name "bugzilla_*" -mtime +$RETENTION_DAYS -delete


# Verify backups
echo "Verifying backups..."
for file in $BACKUP_DIR/*_$TIMESTAMP.*; do
  if [ -f "$file" ]; then
    size=$(du -h "$file" | awk '{print $1}')
    echo "✓ Created: $(basename $file) ($size)"
  fi
done


# Calculate total backup size
TOTAL_SIZE=$(du -sh $BACKUP_DIR | awk '{print $1}')


echo ""
echo "Backup completed at: $TIMESTAMP"
echo "Total backup size: $TOTAL_SIZE"
echo "Backup location: $BACKUP_DIR"


# Database maintenance
echo ""
echo "Running database optimization..."
mysql -h"$DB_HOST" -u"$DB_USER" -p"$DB_PASSWORD" "$DB_NAME" -e "OPTIMIZE TABLE bugs, bugs_activity, attachments;"


echo "✓ Database optimization completed"

cURL - REST API Integration Examples

Terminal window
# Bugzilla REST API Examples


# Get bug details
curl -s https://bugs.yourdomain.com/rest/bug/1 | jq


# List recent bugs
curl -s https://bugs.yourdomain.com/rest/bug?last_change_time=2024-01-01T00:00:00Z | jq


# Search bugs by product
curl -s https://bugs.yourdomain.com/rest/bug?product=MyProduct | jq


# Get bug comments
curl -s https://bugs.yourdomain.com/rest/bug/1/comment | jq


# Get user info
curl -s -H "X-BUGZILLA-API-KEY: YOUR_API_KEY" \
  https://bugs.yourdomain.com/rest/user/admin@yourdomain.com | jq


# Create new bug
curl -X POST https://bugs.yourdomain.com/rest/bug \
  -H "Content-Type: application/json" \
  -H "X-BUGZILLA-API-KEY: YOUR_API_KEY" \
  -d '{
    "product": "MyProduct",
    "component": "MyComponent",
    "summary": "New bug report",
    "description": "Bug description here",
    "version": "1.0",
    "assigned_to": "developer@yourdomain.com"
  }'


# Update bug status
curl -X PUT https://bugs.yourdomain.com/rest/bug/1 \
  -H "Content-Type: application/json" \
  -H "X-BUGZILLA-API-KEY: YOUR_API_KEY" \
  -d '{
    "status": "RESOLVED",
    "resolution": "FIXED"
  }'


# Add comment to bug
curl -X POST https://bugs.yourdomain.com/rest/bug/1/comment \
  -H "Content-Type: application/json" \
  -H "X-BUGZILLA-API-KEY: YOUR_API_KEY" \
  -d '{
    "comment": "This bug has been fixed in version 2.0"
  }'

Bug Tracking Best Practices

Workflow Management

Organize bug workflow:

  1. Define Clear Statuses: NEW, ASSIGNED, RESOLVED, CLOSED
  2. Use Resolutions: FIXED, WONTFIX, DUPLICATE, INVALID
  3. Set Priorities: Critical, High, Medium, Low
  4. Use Severity Levels: Critical, Major, Minor, Trivial
  5. Create Milestones: Track release targets
  6. Monitor Progress: Review open bugs regularly

Component Organization

Structure your products:

  1. Create Logical Components: Match development areas
  2. Assign Ownership: Each component has owner
  3. Clear Descriptions: Components are self-explanatory
  4. Default Assignments: Route bugs appropriately
  5. Component Metrics: Track bugs per component
  6. Regular Review: Remove unused components

Triage and Workflow

Process incoming bugs:

  1. Quick Assessment: Verify bug validity
  2. Duplicate Detection: Check for existing reports
  3. Priority Assignment: Set appropriate priority
  4. Component Assignment: Route to correct team
  5. Severity Rating: Assess impact
  6. Assignment: Assign to developer/team

Communication

Keep stakeholders informed:

  1. Email Notifications: Automatic updates
  2. Status Tracking: Monitor progress
  3. Comment Updates: Keep relevant parties informed
  4. Resolution Reporting: Document fixes
  5. Release Notes: Track resolved issues
  6. Metrics Reporting: Share team statistics

Troubleshooting

Common Issues and Solutions

Issue: Bugzilla not loading

Solutions:

  • Verify MySQL is running
  • Check database credentials
  • Review Apache error logs
  • Verify Perl modules installed
  • Test database connection

Issue: Email not sending

Troubleshooting:

  • Verify SMTP configuration
  • Check sender email address
  • Test SMTP credentials
  • Review mail logs
  • Monitor email queue

Issue: Slow performance

Solutions:

  • Optimize database indexes
  • Run Bugzilla sanity check
  • Clean up old data
  • Increase server resources
  • Monitor database size

Issue: Login problems

Troubleshooting:

  • Check user account enabled
  • Verify email configuration
  • Clear browser cookies
  • Test password reset
  • Review authentication settings

Issue: Attachment upload failing

Solutions:

  • Check attachment directory permissions
  • Verify persistent volume mounted
  • Check available disk space
  • Review upload size limits
  • Check file type restrictions

Updating Bugzilla

To update Bugzilla to a newer version:

  1. Backup database and files
  2. Update Dockerfile with latest version
  3. Commit and push to GitHub
  4. Klutch.sh automatically rebuilds
  5. Test all bug tracking features
  6. Verify database migrations
  7. Monitor logs for issues

Use Cases

Software Development Teams

  • Track bugs and issues during development
  • Manage feature requests
  • Coordinate development work
  • Release management

Quality Assurance

  • Log test results and issues
  • Manage test case tracking
  • Report reproducible bugs
  • Track regression testing

Open Source Projects

  • Community bug reporting
  • Distributed team coordination
  • Public issue tracking
  • Release planning

Customer Support

  • Track customer-reported issues
  • Manage support tickets
  • Prioritize fixes
  • Document resolutions

Additional Resources

Conclusion

Deploying Bugzilla on Klutch.sh provides you with a powerful, scalable bug tracking system trusted by some of the world’s largest open source projects and enterprises. With comprehensive features including advanced search, product and component organization, milestone tracking, custom workflows, email integration, REST API support, and extensive customization options, Bugzilla enables you to streamline your development process and improve product quality. Klutch.sh’s managed infrastructure ensures your bug tracking system is always available, secure, and performant, allowing your team to focus on building great software.

Start tracking bugs effectively today by deploying Bugzilla on Klutch.sh and experience the reliability that powers thousands of projects worldwide.