max_concurrent_automatic_sstable_upgrades

Error message

max_concurrent_automatic_sstable_upgrades ({}) is larger than concurrent_compactors ({})

What it means

max_concurrent_automatic_sstable_upgrades limits how many SSTables are concurrently auto-upgraded (e.g. after changing a compaction or compression setting). If it is set higher than concurrent_compactors, there are not enough compactor threads to ever reach that concurrency, so DatabaseDescriptor logs this warning via validateMaxConcurrentAutoUpgradeTasksConf.

Solutions

Set max_concurrent_automatic_sstable_upgrades to a value <= concurrent_compactors (e.g. nodetool setmaxconcurrentautoupgradetasks <concurrent_compactors>)
Or raise concurrent_compactors to match or exceed the auto-upgrade limit
Verify with nodetool getconcurrentcompactors and nodetool getmaxconcurrentautoupgradetasks

Example fix

// before
nodetool setmaxconcurrentautoupgradetasks 16   # with 8 compactors
// after
nodetool setmaxconcurrentautoupgradetasks 8

Defensive patterns

Strategy: validation

Validate before calling

int compactors = DatabaseDescriptor.getConcurrentCompactors();
if (cfg.maxConcurrentAutoUpgradeTasks > compactors) System.out.println("Lowering auto-upgrade tasks to " + compactors);

Try / catch

try { DatabaseDescriptor.validateMaxConcurrentAutoUpgradeTasksConf(v); } catch (ConfigurationException e) { /* negative value */ }

Prevention

Reconcile the two settings after changing concurrent_compactors
Use nodetool getmaxconcurrentautoupgradetasks vs getconcurrentcompactors in health checks
Default max_concurrent_automatic_sstable_upgrades to -1 (unbounded/auto) unless tuning

When it happens

Trigger: Calling nodetool setmaxconcurrentautoupgradetasks N or setconcurrent_compactors after it, such that N > getConcurrentCompactors(); the validation runs on config updates with a negative value throwing ConfigurationException instead.

Common situations: Operators raising the auto-upgrade limit to speed post-config SSTable upgrades without checking the compactor count; lowering concurrent_compactors later leaves the stale larger upgrade limit in place.

Understand the failure class

Background: "Invalid value" and "allowed values are" config errors: what your library rejected and how to fix it — this error's family across 41 libraries.

Related errors

AI-assisted analysis of apache/cassandra@88fd0f6a0e (2026-09-10). Data as JSON: /api/errors/39a3355f6c626173. Report an issue: GitHub.

Appendix: source

Thrown at src/java/org/apache/cassandra/config/DatabaseDescriptor.java:5238

    public static int maxConcurrentAutoUpgradeTasks()
    {
        return conf.max_concurrent_automatic_sstable_upgrades;
    }

    public static void setMaxConcurrentAutoUpgradeTasks(int value)
    {
        if (conf.max_concurrent_automatic_sstable_upgrades != value)
            logger.debug("Changing max_concurrent_automatic_sstable_upgrades to {}", value);
        validateMaxConcurrentAutoUpgradeTasksConf(value);
        conf.max_concurrent_automatic_sstable_upgrades = value;
    }

    private static void validateMaxConcurrentAutoUpgradeTasksConf(int value)
    {
        if (value < 0)
            throw new ConfigurationException("max_concurrent_automatic_sstable_upgrades can't be negative");
        if (value > getConcurrentCompactors())
            logger.warn("max_concurrent_automatic_sstable_upgrades ({}) is larger than concurrent_compactors ({})", value, getConcurrentCompactors());
    }

    public static AuditLogOptions getAuditLoggingOptions()
    {
        return conf.audit_logging_options;
    }

    public static void setAuditLoggingOptions(AuditLogOptions auditLoggingOptions)
    {
        conf.audit_logging_options = new AuditLogOptions.Builder(auditLoggingOptions).build();
    }

    public static Config.CorruptedTombstoneStrategy getCorruptedTombstoneStrategy()
    {
        return conf.corrupted_tombstone_strategy;
    }

    public static void setCorruptedTombstoneStrategy(Config.CorruptedTombstoneStrategy strategy)

View on GitHub (pinned to 88fd0f6a0e)