Status

Draft. Starting at around this e-mail, the zipkin-dev mailing list started to discuss what exactly Zipkin releases under ASF would look like. This is a complex topic, and this document is a whiteboard to capture it. This should then lead to a proposal, and a decision, the result of which might be captured here or somewhere else.

Pre-ASF

The decision to release a new version was usually made by whichever core contributor felt ownership for the project in question. A majority of releases were initiated by Adrian Cole. Technologically releases of the Zipkin server were triggered by anyone with commit rights pushing a tag release-N.M.L to a commit on the master branch. The automated release pipeline is described in detail in RELEASE.md. The built artifacts were uploaded to BinTray, Maven Central. Docker image builds were then manually triggered in a similar way, and were uploaded to Docker Hub. Most Zipkin projects were set up in a similar way – for this document, we'll assume full homogeneity. Release cadence was “whenever we feel like it”, sometimes multiple times a week.

Considerations for releasing under ASF

Requirements / constraints from ASF

These are constraints we have to work with, and can not change. Do note that this document is not necessarily correct. This part is subject to change as we learn more about the actual requirements set by ASF. The authoritative source are the ASF Incubator Release Management and ASF Software Product Releases documents. Especially relevant to Zipkin, since it's using Maven for most builds, is Publishing Maven Artifacts.

These are preferences from Zipkin contributors, derived from an understanding of existing development practices and the specific needs and expectations of the Zipkin user community.

  • Keep release overhead as low as possible, while satisfying ASF requirements
  • (question) Do we want to synchronize releases of the various Zipkin projects?

Options

Release processes of other Apache projects with similar requirements we may learn from:

A. Only formal releases

This is a bare-bones approach minimizing tooling investment. For simplicity, let's examine the release process of the main Zipkin server under this model.

On commits to master:

  • Passing CI test jobs on master upload SNAPSHOT artifacts to the shapshots ASF repo, just like they do now (except until now they lived on Sonatype). Artifact: zipkin-server 2.11.6-SNAPSHOT
  • No Docker images are built. It's possible to put in some tooling work to allow triggering the build of "snapshot" Docker images from specific JARs.

When tag rc-2.11.6 is pushed:

  • Release notes are written and committed into the repo
  • CI builds an artifact with version 2.11.6, and uploads it to the dev repo. This will be the final release artifact if the release vote passes.
  • This triggers an automated Docker build, creating an image labeled 2.11.6-rc
  • Formal vote process takes place. If the vote fails, stop here. If the vote passes:
  • The 2.11.6 JAR is promoted to the release Maven repository. The previously built Docker image receives the label 2.11.6. These can initially be done manually, and are great candidates to encapsulate in CI jobs (either started manually on Jenkins, or by pushing a tag release-2.11.6 and utilizing Travis / Circle).
  • Release is announced on channels (to be documented before this process is finalized)

B. Only formal releases, with extra tooling to share dev builds

This allows more flexibility in distributing builds that are not official releases.

First: do everything from Option A (big grin)

When tag dev-$USER-$FEATURE is pushed, with the current snapshot version being 2.11.7-SNAPSHOT, where $USER wants to get a build to someone so they can try out $FEATURE, or verify a fix, or anything else along those lines:

  • CI uploads an artifact 2.11.7-$USER-$FEATURE to the dev repository
  • This triggers an automated Docker build, creating an image labeled dev-2.11.7-$USER-$FEATURE.

These artifacts are temporary, and are automatically cleaned up after a month of being uploaded.

C. ???

Add any more ideas here.

  • No labels

3 Comments

  1. incidentally this reminds me a little of the piece we wrote "how change works" https://zipkin.io/pages/community.html

  2. do we want to describe CI here or only release?

    1. What do you mean by CI in this context? My understanding is we keep the current systems (Travis, Circle), so the only CI-related change would be implementing whatever process we come up here in the existing automation.