apache/kafka · error · Exception

Release {version} is not complete since there are unresolve

Error message

Release {version} is not complete since there are unresolved or improperly
resolved issues tagged {version} as the fix version:

{issue_list}

Note that for some resolutions, you should simply remove the fix version
as they have not been truly fixed in this release.

What it means

Thrown by the Apache Kafka release-notes generator (release/notes.py) when JIRA issues tagged with the target version as their fixVersion have resolutions that do not represent a genuine fix. filter_unresolved() treats any resolution in {None, 'Unresolved', 'Duplicate', 'Invalid', 'Not A Problem', 'Not A Bug', "Won't Fix", 'Incomplete', 'Cannot Reproduce', 'Later', 'Works for Me', 'Workaround', 'Information Provided'} as not-really-fixed. The check exists to guarantee release notes only list work actually shipped, blocking the release until every tagged issue is either truly Fixed or untagged.

Source

Thrown at release/notes.py:152

    """
    key = "%15s" % issue.key
    resolution = "%15s" % issue.fields.resolution
    link = issue_link(issue)
    return f"{key} {resolution} {link}"

def generate(version):
    """
    Generates the release notes in HTML format for given version.
    Raises an error if there are unresolved issues or no issues
    at all for the specified version.
    """
    issues = query(f"project=KAFKA and fixVersion={version}")
    if not issues:
        raise Exception(f"Didn't find any issues for version {version}")
    unresolved_issues = filter_unresolved(issues)
    if unresolved_issues:
        issue_list = "\n".join([issue_str(issue) for issue in unresolved_issues])
        raise Exception(f"""
Release {version} is not complete since there are unresolved or improperly
resolved issues tagged {version} as the fix version:

{issue_list}

Note that for some resolutions, you should simply remove the fix version
as they have not been truly fixed in this release.
        """)
    return render(version, issues)


if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python notes.py <version>", file=sys.stderr)
        sys.exit(1)

    version = sys.argv[1]
    try:

View on GitHub (pinned to 996fb4585a)

Solutions

  1. Read the issue_list in the error message, then in JIRA remove the fixVersion=<version> from every issue that was NOT actually fixed in this release (duplicates, won't-fix, invalid, cannot-reproduce).
  2. For issues that ARE fixed but show resolution=None, set their JIRA resolution to 'Fixed' (or another acceptable resolution) and reopen the script.
  3. For issues still in progress, move their fixVersion to a future release so they drop out of this query.
  4. Re-run `python notes.py <version>`; it only succeeds once filter_unresolved() returns an empty list.
  5. If the release is genuinely incomplete, do not suppress this error - finish the work in JIRA first.

Example fix

// This is a JIRA data error, not a code change. No edit to notes.py is correct.

// before (JIRA state causing the error):
//   KAFKA-12345  fixVersion=3.8.0  resolution=Duplicate
//   KAFKA-12346  fixVersion=3.8.0  resolution=None
//   KAFKA-12347  fixVersion=3.8.0  resolution=Won't Fix
// -> `python notes.py 3.8.0` raises the error listing all three.

// after (fix in JIRA, then re-run):
//   KAFKA-12345  (remove fixVersion 3.8.0)         // was a duplicate
//   KAFKA-12346  fixVersion=3.8.0  resolution=Fixed  // now genuinely fixed
//   KAFKA-12347  fixVersion=3.9.0  resolution=None    // moved to next release
// -> `python notes.py 3.8.0` now emits RELEASE_NOTES.html successfully.
Defensive patterns

Strategy: validation

Validate before calling

# Run BEFORE calling generate(version) to fail fast with a clear message.
# Reuses the same query + filter so it matches notes.py exactly.
from release import notes

def assert_release_ready(version):
    issues = notes.query(f"project=KAFKA and fixVersion={version}")
    if not issues:
        raise ValueError(f"No issues found for {version} - wrong version string?")
    unresolved = notes.filter_unresolved(issues)
    if unresolved:
        keys = ", ".join(i.key for i in unresolved)
        raise ValueError(
            f"Release {version} not ready. Untag/move/fix these in JIRA first: {keys}"
        )
    return issues  # safe to call notes.generate(version) now

issues = assert_release_ready("3.8.0")
html = notes.generate("3.8.0")

Try / catch

# The script itself (notes.py:164-174) already wraps generate() - mirror it.
import sys
from release import notes

try:
    print(notes.generate(version))
except Exception as e:
    # Surface the embedded issue_list so the release manager can act on JIRA.
    print(e, file=sys.stderr)
    sys.exit(1)

Prevention

When it happens

Trigger: Calling generate(version) (or running `python notes.py <version>`) such that the JQL query `project=KAFKA and fixVersion=<version>` returns at least one issue, and at least one returned issue has issue.fields.resolution equal to None or whose .name is one of the UNRESOLVED_RESOLUTIONS listed in filter_unresolved(). The exception is raised at notes.py:152 after building issue_list from those issues.

Common situations: Release manager generates notes before all issues are properly resolved; an issue was closed as Duplicate/Won't Fix/Invalid but its fixVersion was never cleared; bulk JIRA edits or version renames left stale fixVersion tags; an issue is still genuinely open (resolution=None) yet already carries the upcoming version; a sub-task was moved out but the parent kept the fixVersion.

Related errors

AI-assisted analysis of apache/kafka@996fb4585a (2026-08-11). Data as JSON: /api/errors/8bbc4dea892f0073. Report an issue: GitHub.