open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Sync release workflow (#4333) 

* Sync release workflow

* Add example sending PR to another repo

* Use simpler sharing of env vars across steps

* Simplify, merge related jobs

* Simplify

* More improvements

* Use release/* release branch naming

* Add note about markdownlint
This commit is contained in:
Trask Stalnaker 2022-04-04 19:22:36 -07:00 committed by GitHub
parent ccbb28087a
commit 82db72abcc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 498 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
.github/scripts/generate-release-contributors.sh vendored Normal file
View File

@ -0,0 +1,82 @@
#!/bin/bash -e
# shellcheck disable=SC2016
# shellcheck disable=SC2086
from_version=$1
to_version=$2
# get the date of the first commit on main that wasn't in the from_version
from=$(git log --reverse --pretty=format:"%cI" $from_version..HEAD | head -1)
# get the last commit on main that was in the to_version
to=$(git merge-base HEAD $to_version | xargs git log -1 --pretty=format:"%cI")
contributors1=$(gh api graphql --paginate -F q="repo:$GITHUB_REPOSITORY is:pr base:main is:merged merged:$from..$to" -f query='
query($q: String!, $endCursor: String) {
search(query: $q, type: ISSUE, first: 100, after: $endCursor) {
edges {
node {
... on PullRequest {
author { login }
reviews(first: 100) {
nodes {
author { login }
}
}
comments(first: 100) {
nodes {
author { login }
}
}
closingIssuesReferences(first: 100) {
nodes {
author { login }
}
}
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}' --jq '.data.search.edges.[].node.author.login,
.data.search.edges.[].node.reviews.nodes.[].author.login,
.data.search.edges.[].node.comments.nodes.[].author.login,
.data.search.edges.[].node.closingIssuesReferences.nodes.[].author.login')
# this query captures authors of issues which have had PRs in the current range reference the issue
# but not necessarily through closingIssuesReferences (e.g. addressing just a part of an issue)
contributors2=$(gh api graphql --paginate -F q="repo:$GITHUB_REPOSITORY is:pr base:main is:merged merged:$from..$to" -f query='
query($q: String!, $endCursor: String) {
search(query: $q, type: ISSUE, first: 100, after: $endCursor) {
edges {
node {
... on PullRequest {
body
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
' --jq '.data.search.edges.[].node.body' \
| grep -oE "#[0-9]{4,}|issues/[0-9]{4,}" \
| grep -oE "[0-9]{4,}" \
| xargs -I{} gh issue view {} --json 'author,url' --jq '[.author.login,.url]' \
| grep -v '/pull/' \
| sed 's/^\["//' \
| sed 's/".*//')
echo $contributors1 $contributors2 \
| sed 's/ /\n/g' \
| sort -uf \
| grep -v linux-foundation-easycla \
| grep -v github-actions \
| grep -v dependabot \
| sed 's/^/@/'

38
.github/workflows/backport.yml vendored Normal file
View File

@ -0,0 +1,38 @@
name: Backport
on:
workflow_dispatch:
inputs:
number:
description: "The pull request # to backport"
required: true
jobs:
backport:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
# history is needed in order to do cherry-pick
fetch-depth: 0
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
- name: Create pull request
env:
NUMBER: ${{ github.event.inputs.number }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
commit=$(gh pr view $NUMBER --json mergeCommit --jq .mergeCommit.oid)
title=$(gh pr view $NUMBER --json title --jq .title)
url=$(gh pr view $NUMBER --json url --jq .url)
git cherry-pick $commit
git push origin HEAD:backport-$NUMBER-to-$GITHUB_REF_NAME
gh pr create --title "[$GITHUB_REF_NAME] $title" \
--body "Clean cherry-pick of #$NUMBER to the $GITHUB_REF_NAME branch." \
--head backport-$NUMBER-to-$GITHUB_REF_NAME \
--base $GITHUB_REF_NAME

2
.github/workflows/build.yml vendored
View File

@ -4,7 +4,7 @@ on:
push:
branches:
- main
- v[0-9]+.[0-9]+.x
- release/*
workflow_dispatch:
jobs:

2
.github/workflows/docker-test-containers.yml → .github/workflows/docker-test-containers-daily.yml vendored
View File

@ -1,4 +1,4 @@
name: Copy test container docker images
name: Copy test container docker images (daily)
on:
schedule:

97
.github/workflows/patch-release-build.yml vendored
View File

@ -1,97 +0,0 @@
# Releases a patch by cherrypicking commits into a release branch based on the previous
# release tag.
name: Patch Release Build
on:
workflow_dispatch:
inputs:
version:
description: The version to tag the release with, e.g., 1.2.1, 1.2.2
required: true
commits:
description: Comma separated list of commit shas to cherrypick, leave blank if changes have already been merged into the release branch
required: false
jobs:
prepare-release-branch:
runs-on: ubuntu-20.04
outputs:
release-branch-name: ${{ steps.parse-release-branch.outputs.release-branch-name }}
steps:
- id: parse-release-branch
name: Parse release branch name
run: |
# Sets the release-branch-name output to the version number with the last non-period element replaced with an 'x' and preprended with v.
echo "::set-output name=release-branch-name::$(echo '${{ github.event.inputs.version }}' | sed -E 's/([^.]+)\.([^.]+)\.([^.]+)/v\1.\2.x/')"
# Sets the release-tag-name output to the version number with the last non-period element replace with a '0' and prepended with v
echo "::set-output name=release-tag-name::$(echo '${{ github.event.inputs.version }}' | sed -E 's/([^.]+)\.([^.]+)\.([^.]+)/v\1.\2.0/')"
- id: checkout-release-branch
name: Check out release branch
continue-on-error: true
uses: actions/checkout@v3
with:
ref: ${{ steps.parse-release-branch.outputs.release-branch-name }}
- id: checkout-release-tag
name: Check out release tag
if: ${{ steps.checkout-release-branch.outcome == 'failure' }}
uses: actions/checkout@v3
with:
ref: ${{ steps.parse-release-branch.outputs.release-tag-name }}
- name: Create release branch
if: ${{ steps.checkout-release-tag.outcome == 'success' }}
run: |
git checkout -b ${{ steps.parse-release-branch.outputs.release-branch-name }}
git push --set-upstream origin ${{ steps.parse-release-branch.outputs.release-branch-name }}
build:
runs-on: ubuntu-20.04
needs: prepare-release-branch
steps:
- name: Checkout release branch
uses: actions/checkout@v3
with:
ref: ${{ needs.prepare-release-branch.outputs.release-branch-name }}
- uses: actions/setup-java@v2
with:
distribution: temurin
java-version: 17
- name: Set up git name
run: |
git config user.name github-actions
git config user.email github-actions@github.com
- name: Cherrypicks
if: ${{ github.event.inputs.commits != '' }}
run: |
git fetch origin main
echo ${{ github.event.inputs.commits }} | sed -n 1'p' | tr ',' '\n' | while read word; do
# Trim whitespaces and cherrypick
echo $word | sed 's/ *$//g' | sed 's/^ *//g' | git cherry-pick --stdin
done
- uses: gradle/gradle-build-action@v2
with:
arguments: |
build
-Prelease.version=${{ github.event.inputs.version }}
- uses: gradle/gradle-build-action@v2
name: Publish artifacts
with:
arguments: |
final
closeAndReleaseSonatypeStagingRepository
-Prelease.version=${{ github.event.inputs.version }}
env:
GRGIT_USER: ${{ github.actor }}
GRGIT_PASS: ${{ secrets.GITHUB_TOKEN }}
SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
SONATYPE_KEY: ${{ secrets.SONATYPE_KEY }}
GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
GPG_PASSWORD: ${{ secrets.GPG_PASSWORD }}
- run: git push

43
.github/workflows/prepare-patch-release.yml vendored Normal file
View File

@ -0,0 +1,43 @@
name: Prepare patch release
on:
workflow_dispatch:
jobs:
prepare-patch-release:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set environment variables
run: |
prior_version=$(grep -Eo "[0-9]+.[0-9]+.[0-9]+" version.gradle.kts | head -1)
if [[ $prior_version =~ ([0-9]+.[0-9]+).([0-9]+) ]]; then
major_minor="${BASH_REMATCH[1]}"
patch="${BASH_REMATCH[2]}"
else
echo "unexpected version: $prior_version"
exit 1
fi
echo "VERSION=$major_minor.$((patch + 1))" >> $GITHUB_ENV
echo "PRIOR_VERSION=$prior_version" >> $GITHUB_ENV
- name: Bump version
run: |
sed -ri "s/$PRIOR_VERSION/$VERSION/" version.gradle.kts
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
- name: Create pull request
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
msg="Prepare release $VERSION"
git commit -a -m "$msg"
git push origin HEAD:prepare-release-$VERSION
gh pr create --title "[$GITHUB_REF_NAME] $msg" \
--body "$msg" \
--head prepare-release-$VERSION \
--base $GITHUB_REF_NAME

78
.github/workflows/prepare-release-branch.yml vendored Normal file
View File

@ -0,0 +1,78 @@
name: Prepare release branch
on:
workflow_dispatch:
jobs:
create-pull-request-against-release-branch:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Create release branch
id: create-release-branch
run: |
version=$(grep -Eo "[0-9]+.[0-9]+.0-SNAPSHOT" version.gradle.kts | sed 's/-SNAPSHOT//')
release_branch_name=$(echo $version | sed -E 's,([0-9]+)\.([0-9]+)\.0,release/v\1.\2.x,')
git push origin HEAD:$release_branch_name
echo "VERSION=$version" >> $GITHUB_ENV
echo "RELEASE_BRANCH_NAME=$release_branch_name" >> $GITHUB_ENV
- name: Bump version
run: |
sed -ri "s/$VERSION-SNAPSHOT/$VERSION/" version.gradle.kts
sed -ri "s/$VERSION-alpha-SNAPSHOT/$VERSION-alpha/" version.gradle.kts
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
- name: Create pull request against release branch
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
msg="Prepare release $VERSION"
git commit -a -m "$msg"
git push origin HEAD:prepare-release-$VERSION
gh pr create --title "[$RELEASE_BRANCH_NAME] $msg" \
--body "$msg" \
--head prepare-release-$VERSION \
--base $RELEASE_BRANCH_NAME
create-pull-request-against-main:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Bump snapshot version
run: |
version=$(grep -Eo "[0-9]+.[0-9]+.0-SNAPSHOT" version.gradle.kts | sed 's/-SNAPSHOT//')
if [[ $version =~ ([0-9]+).([0-9]+).0 ]]; then
major="${BASH_REMATCH[1]}"
minor="${BASH_REMATCH[2]}"
else
echo "unexpected version: $version"
exit 1
fi
next_version="$major.$((minor + 1)).0"
sed -ri "s/$version-SNAPSHOT/$next_version-SNAPSHOT/" version.gradle.kts
sed -ri "s/$version-apha-SNAPSHOT/$next_version-apha-SNAPSHOT/" version.gradle.kts
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
- name: Create pull request against main
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
msg="Bump version"
git commit -a -m "$msg"
git push origin HEAD:bump-snapshot-version
gh pr create --title "$msg" \
--body "$msg" \
--head bump-snapshot-version \
--base main

41
.github/workflows/release-build.yml vendored
View File

@ -1,41 +0,0 @@
# Releases a new minor / major version from the HEAD of the main branch
name: Release Build
on:
workflow_dispatch:
inputs:
version:
description: The version to tag the release with, e.g., 1.2.0, 1.2.1-alpha.1
required: true
jobs:
build:
name: Build and release
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v3
- uses: actions/setup-java@v2
with:
distribution: temurin
java-version: 17
- uses: gradle/gradle-build-action@v2
with:
arguments: |
build
-Prelease.version=${{ github.event.inputs.version }}
- uses: gradle/gradle-build-action@v2
name: Publish artifacts
with:
arguments: |
final
closeAndReleaseSonatypeStagingRepository
-Prelease.version=${{ github.event.inputs.version }}
env:
GRGIT_USER: ${{ github.actor }}
GRGIT_PASS: ${{ secrets.GITHUB_TOKEN }}
SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
SONATYPE_KEY: ${{ secrets.SONATYPE_KEY }}
GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
GPG_PASSWORD: ${{ secrets.GPG_PASSWORD }}

125
.github/workflows/release.yml vendored Normal file
View File

@ -0,0 +1,125 @@
name: Release
on:
workflow_dispatch:
jobs:
release:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v3
- uses: actions/setup-java@v2
with:
distribution: temurin
java-version: 17
- name: Build and publish artifacts
uses: gradle/gradle-build-action@v2
with:
arguments: assemble publishToSonatype closeAndReleaseSonatypeStagingRepository
env:
SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
SONATYPE_KEY: ${{ secrets.SONATYPE_KEY }}
GPG_PRIVATE_KEY: ${{ secrets.GPG_PRIVATE_KEY }}
GPG_PASSWORD: ${{ secrets.GPG_PASSWORD }}
- name: Set versions
id: set-versions
run: |
version=$(grep -Eo "[0-9]+.[0-9]+.[0-9]+" version.gradle.kts | head -1)
if [[ $version =~ ([0-9]+).([0-9]+).([0-9]+) ]]; then
major="${BASH_REMATCH[1]}"
minor="${BASH_REMATCH[2]}"
patch="${BASH_REMATCH[3]}"
else
echo "unexpected version: $version"
exit 1
fi
if [[ $patch == 0 ]]; then
if [[ $minor == 0 ]]; then
prior_major=$((major - 1))
prior_minor=$(grep -Po "^## Version $prior_major.\K([0-9]+)" CHANGELOG.md | head -1)
prior_version="$prior_major.$prior_minor"
else
prior_version="$major.$((minor - 1)).0"
fi
else
prior_version="$major.$minor.$((patch - 1))"
fi
echo "VERSION=$version" >> $GITHUB_ENV
echo "PRIOR_VERSION=$prior_version" >> $GITHUB_ENV
- name: Generate release notes
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
if [[ $version == *.0 ]]; then
cat > release-notes.txt << EOF
This release targets the OpenTelemetry SDK $VERSION.
EOF
else
cat > release-notes.txt << EOF
This is a patch release on the previous $PRIOR_VERSION release, fixing the issue(s) below.
EOF
fi
sed -n "/^## Version $VERSION/,/^## Version /p" CHANGELOG.md \
| tail -n +2 \
| head -n -1 \
| perl -0pe 's/^\n+//g' \
| perl -0pe 's/\n+$/\n/g' \
| sed -r "s,\[#([0-9]+)]\(https://github.com/$GITHUB_REPOSITORY/(pull|issues)/[0-9]+\),#\1," \
| perl -0pe 's/\n +/ /g' \
>> release-notes.txt
if [[ $version == *.0 ]]; then
cat >> release-notes.txt << EOF
### 🙇 Thank you
This release was possible thanks to the following contributors who shared their brilliant ideas and awesome pull requests:
EOF
.github/scripts/generate-release-contributors.sh v$PRIOR_VERSION v$VERSION >> release-notes.txt
fi
- name: Create GitHub release
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh release create --target $GITHUB_REF_NAME \
--title "Version $VERSION" \
--notes-file release-notes.txt \
--discussion-category announcements \
v$VERSION
- uses: actions/checkout@v3
with:
ref: main
# history is needed in order to generate the patch
fetch-depth: 0
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
# this step should be last since it will fail if there have been conflicting
# change log updates introduced on the main branch
- name: Create pull request to merge any change log updates to main
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
git format-patch --stdout main..$GITHUB_REF_NAME CHANGELOG.md > patch
if [ -s patch ]; then
git apply patch
msg="Merge change log updates from $GITHUB_REF_NAME to main"
git commit -a -m "$msg"
git push origin HEAD:merge-change-log-updates-to-main
gh pr create --title "$msg" \
--body "$msg" \
--head merge-change-log-updates-to-main \
--base main
fi

120
RELEASING.md
View File

@ -1,34 +1,51 @@
# OpenTelemetry Release Process
## Starting the Release
Before releasing, it is a good idea to run `./gradlew japicmp` on the main branch
and verify that there are no unexpected public API changes seen in the `docs/apidiffs/current_vs_latest`
directory.
Open the release build workflow in your browser [here](https://github.com/open-telemetry/opentelemetry-java/actions/workflows/release-build.yml).
You will see a button that says "Run workflow". Press the button, enter the version number you want
to release in the input field that pops up, and then press "Run workflow".
This triggers the release process, which builds the artifacts. It will not automatically update the
documentation, because the Github Actions cannot push changes to the main branch.
## Announcement
Once the GitHub workflow completes, go to
Github [release page](https://github.com/open-telemetry/opentelemetry-java/releases), press
`Draft a new release` to write release notes about the new release. If there is already a draft
release notes, just point it at the created tag. Click "Create a discussion for this release" and
select category "Announcements" to create a corresponding discussion upon publish.
You can use `git log upstream/v$MAJOR.$((MINOR-1)).x..upstream/v$MAJOR.$MINOR.x --graph --first-parent`
When preparing the change log, you can use
`git log upstream/v$MAJOR.$((MINOR-1)).x..upstream/v$MAJOR.$MINOR.x --graph --first-parent`
or the Github [compare tool](https://github.com/open-telemetry/opentelemetry-java/compare/)
to view a summary of all commits since last release as a reference.
In addition, you can refer to
[CHANGELOG.md](https://github.com/open-telemetry/opentelemetry-java/blob/main/CHANGELOG.md)
for a list of major changes since last release.
## Preparing a new major or minor release
* Close the release milestone if there is one.
* Merge a pull request to `main` updating the `CHANGELOG.md`.
* Run the [Prepare release branch workflow](.github/workflows/prepare-release-branch.yml).
* Review and merge the two pull requests that it creates
(one is targeted to the release branch and one is targeted to the `main` branch).
## Preparing a new patch release
All patch releases should include only bug-fixes, and must avoid adding/modifying the public APIs.
In general, patch releases are only made for regressions, memory leaks and deadlocks.
* Backport pull request(s) to the release branch
* Run the [Backport workflow](.github/workflows/backport.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `release/v1.9.x`, then enter the pull request number that you want to backport,
then click the "Run workflow" button below that.
* Review and merge the backport pull request that it generates
* Merge a pull request to the release branch updating the `CHANGELOG.md`
* Run the [Prepare patch release workflow](.github/workflows/prepare-patch-release.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `release/v1.9.x`, and click the "Run workflow" button below that.
* Review and merge the pull request that it creates
## Making the release
Run the [Release workflow](.github/workflows/release.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `release/v1.9.x`, and click the "Run workflow" button below that.
* This workflow will publish the artifacts to maven central and will publish a GitHub release with
release notes based on the change log and with the javaagent jar attached.
* Lastly, if there were any change log updates in the release branch that need to be merged back to
the main branch, the workflow will create a pull request if the updates can be cleanly applied,
or it will fail this last step if the updates cannot be cleanly applied.
## Update release versions in documentations and CHANGELOG files
@ -52,65 +69,6 @@ Finally, update the [website docs][] to refer to the newly released version.
[website docs]: https://github.com/open-telemetry/opentelemetry.io/tree/main/content/en/docs/instrumentation/java
## Patch Release
All patch releases should include only bug-fixes, and must avoid
adding/modifying the public APIs.
Open the patch release build workflow in your browser [here](https://github.com/open-telemetry/opentelemetry-java/actions/workflows/patch-release-build.yml).
You will see a button that says "Run workflow". Press the button, enter the version number you want
to release in the input field for version that pops up and the commits you want to cherrypick for the
patch as a comma-separated list. Then, press "Run workflow".
If the commits cannot be cleanly applied to the release branch, for example because it has diverged
too much from main, then the workflow will fail before building. In this case, you will need to
prepare the release branch manually.
This example will assume patching into release branch `v1.2.x` from a git repository with remotes
named `origin` and `upstream`.
```
$ git remote -v
origin git@github.com:username/opentelemetry-java.git (fetch)
origin git@github.com:username/opentelemetry-java.git (push)
upstream git@github.com:open-telemetry/opentelemetry-java.git (fetch)
upstream git@github.com:open-telemetry/opentelemetry-java.git (push)
```
First, checkout the release branch
```
git fetch upstream v1.2.x
git checkout upstream/v1.2.x
```
If the release branch does not exist, checkout the tag, create the release branch from it, and push
it to the `upstream`.
```
git fetch upstream v1.2.0
git checkout v1.2.0
git checkout -b v1.2.x
git push upstream v1.2.x
```
Apply cherrypicks manually and commit. It is ok to apply multiple cherrypicks in a single commit.
Use a commit message such as "Manual cherrypick for commits commithash1, commithash2".
After committing the change, push to your fork's branch.
```
git push origin v1.2.x
```
Create a PR to have code review and merge this into upstream's release branch. As this was not
applied automatically, we need to do code review to make sure the manual cherrypick is correct.
After it is merged, Run the patch release workflow again, but leave the commits input field blank.
The release will be made with the current state of the release branch, which is what you prepared
above.
## Credentials
The following credentials are required for publishing (and automatically set in Circle CI):

22
build.gradle.kts
View File

@ -1,10 +1,8 @@
import nebula.plugin.release.git.opinion.Strategies
import java.time.Duration
plugins {
id("com.github.ben-manes.versions")
id("io.github.gradle-nexus.publish-plugin")
id("nebula.release")
id("otel.spotless-conventions")
}
@ -18,25 +16,7 @@ if (!JavaVersion.current().isJava11Compatible()) {
)
}
// Nebula plugin will not configure if .git doesn't exist, let's allow building on it by stubbing it
// out. This supports building from the zip archive downloaded from GitHub.
var releaseTask: TaskProvider<Task>
if (file(".git").exists()) {
release {
defaultVersionStrategy = Strategies.getSNAPSHOT()
}
nebulaRelease {
addReleaseBranchPattern("""v\d+\.\d+\.x""")
}
releaseTask = tasks.named("release")
releaseTask.configure {
mustRunAfter("snapshotSetup", "finalSetup")
}
} else {
releaseTask = tasks.register("release")
}
apply(from = "version.gradle.kts")
nexusPublishing {
packageGroup.set("io.opentelemetry")

14
buildSrc/src/main/kotlin/otel.publish-conventions.gradle.kts
View File

@ -8,12 +8,6 @@ plugins {
publishing {
publications {
register<MavenPublication>("mavenPublication") {
val release = findProperty("otel.release")
if (release != null) {
val versionParts = version.split('-').toMutableList()
versionParts[0] += "-$release"
version = versionParts.joinToString("-")
}
groupId = "io.opentelemetry"
afterEvaluate {
// not available until evaluated.
@ -63,14 +57,6 @@ publishing {
}
}
afterEvaluate {
val publishToSonatype by tasks.getting
val release by rootProject.tasks.existing
release.configure {
finalizedBy(publishToSonatype)
}
}
if (System.getenv("CI") != null) {
signing {
useInMemoryPgpKeys(System.getenv("GPG_PRIVATE_KEY"), System.getenv("GPG_PASSWORD"))

139
docs/common-github-actions-practices.md
View File

@ -27,6 +27,7 @@ Once we agree and implement, will share more broadly across OpenTelemetry
- [Prepare patch](#prepare-patch)
- [Backporting pull requests to a release branch](#backporting-pull-requests-to-a-release-branch)
- [Release](#release)
- [Sending a pull request to another repository](#sending-a-pull-request-to-another-repository)
- [Workflow file naming conventions](#workflow-file-naming-conventions)
- [Workflow YAML style guide](#workflow-yaml-style-guide)
@ -213,7 +214,9 @@ requests if new misspellings are added to the misspell dictionary.
Specification repo uses https://github.com/DavidAnson/markdownlint.
Go repo uses https://github.com/avto-dev/markdown-lint.
Go, JavaScript repos use https://github.com/avto-dev/markdown-lint github action.
C++ uses markdownlint-cli (which is same that is used by avto-dev/markdown-lint github action).
TODO
@ -343,13 +346,13 @@ Here's some sample `RELEASING.md` documentation that goes with the automation be
* Backport pull request(s) to the release branch
* Run the [Backport workflow](.github/workflows/backport.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `v1.9.x`, then enter the pull request number that you want to backport,
e.g. `release/v1.9.x`, then enter the pull request number that you want to backport,
then click the "Run workflow" button below that.
* Review and merge the backport pull request that it generates
* Merge a pull request to the release branch updating the `CHANGELOG.md`
* Run the [Prepare patch release workflow](.github/workflows/prepare-patch-release.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `v1.9.x`, and click the "Run workflow" button below that.
e.g. `release/v1.9.x`, and click the "Run workflow" button below that.
* Review and merge the pull request that it creates
## Making the release
@ -357,7 +360,7 @@ Here's some sample `RELEASING.md` documentation that goes with the automation be
Run the [Release workflow](.github/workflows/release.yml).
* Press the "Run workflow" button, then select the release branch from the dropdown list,
e.g. `v1.9.x`, and click the "Run workflow" button below that.
e.g. `release/v1.9.x`, and click the "Run workflow" button below that.
* This workflow will publish the artifacts to maven central and will publish a GitHub release
with release notes based on the change log.
* Lastly, if there were any change log updates in the release branch that need to be merged back
@ -381,7 +384,9 @@ This is what we use in the OpenTelemetry Java repositories:
### Prepare release branch
The specifics depend a lot on your specific version bumping needs.
Uses release branch naming convention `release/v*`.
The specifics below depend a lot on your specific version bumping needs.
For OpenTelemetry Java repositories, the version in the `main` branch always ends with `-SNAPSHOT`,
so preparing the release branch involves
@ -397,38 +402,25 @@ on:
workflow_dispatch:
jobs:
prepare-release-branch:
create-pull-request-against-release-branch:
runs-on: ubuntu-latest
outputs:
release-branch-name: ${{ steps.set-release-branch-name.outputs.release-branch-name }}
steps:
- uses: actions/checkout@v3
- name: Set release branch name
id: set-release-branch-name
run: |
version=$(...) <-- get the version that is planned to be released
release_branch_name=$(echo $version | sed -E 's/([0-9]+)\.([0-9]+)\.0/v\1.\2.x/')
echo "::set-output name=release-branch-name::$release_branch_name"
- name: Create release branch
env:
RELEASE_BRANCH_NAME: ${{ steps.set-release-branch-name.outputs.release-branch-name }}
id: create-release-branch
run: |
git push origin HEAD:$RELEASE_BRANCH_NAME
version=$(...) <-- get the version that is planned to be released
release_branch_name=$(echo $version | sed -E 's,([0-9]+)\.([0-9]+)\.0,release/v\1.\2.x,')
create-pull-request-against-release-branch:
needs: prepare-release-branch
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
with:
ref: ${{ needs.prepare-release-branch.outputs.release-branch-name }}
git push origin HEAD:$release_branch_name
- name: Bump version on release branch
echo "VERSION=$version" >> $GITHUB_ENV
echo "RELEASE_BRANCH_NAME=$release_branch_name" >> $GITHUB_ENV
- name: Bump version
run: |
version=$(...) <-- get the minor version that is planning to be released
.github/scripts/update-versions.sh $version-SNAPSHOT $version
.github/scripts/update-versions.sh $VERSION-SNAPSHOT $VERSION
- name: Set up git name
run: |
@ -439,20 +431,16 @@ jobs:
- name: Create pull request against release branch
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
RELEASE_BRANCH_NAME: ${{ needs.prepare-release-branch.outputs.release-branch-name }}
run: |
msg="Prepare release branch $RELEASE_BRANCH_NAME"
msg="Prepare release $VERSION"
git commit -a -m "$msg"
git push origin HEAD:prepare-release-branch-$RELEASE_BRANCH_NAME
gh pr create --title "$msg" \
git push origin HEAD:prepare-release-$VERSION
gh pr create --title "[$RELEASE_BRANCH_NAME] $msg" \
--body "$msg" \
--head prepare-release-branch-$RELEASE_BRANCH_NAME \
--head prepare-release-$VERSION \
--base $RELEASE_BRANCH_NAME
create-pull-request-against-main:
needs:
- prepare-release-branch
- create-pull-request-against-release-branch
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
@ -507,8 +495,7 @@ jobs:
steps:
- uses: actions/checkout@v3
- name: Set versions
id: set-versions
- name: Set environment variables
run: |
prior_version=$(...) <-- get the prior release version
if [[ $prior_version =~ ([0-9]+.[0-9]+).([0-9]+) ]]; then
@ -518,13 +505,10 @@ jobs:
echo "unexpected version: $prior_version"
exit 1
fi
echo "::set-output name=release-version::$major_minor.$((patch + 1))"
echo "::set-output name=prior-release-version::$prior_version"
echo "VERSION=$major_minor.$((patch + 1))" >> $GITHUB_ENV
echo "PRIOR_VERSION=$prior_version" >> $GITHUB_ENV
- name: Bump version
env:
VERSION: ${{ needs.set-versions.outputs.release-version }}
PRIOR_VERSION: ${{ needs.set-versions.outputs.prior-release-version }}
run: |
.github/scripts/update-versions.sh $PRIOR_VERSION $VERSION
@ -536,15 +520,14 @@ jobs:
- name: Create pull request
env:
VERSION: ${{ needs.set-versions.outputs.release-version }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
msg="Prepare patch release $VERSION"
msg="Prepare release $VERSION"
git commit -a -m "$msg"
git push origin HEAD:prepare-patch-release-$VERSION
gh pr create --title "$msg" \
git push origin HEAD:prepare-release-$VERSION
gh pr create --title "[$GITHUB_REF_NAME] $msg" \
--body "$msg" \
--head prepare-patch-release-$VERSION \
--head prepare-release-$VERSION \
--base $GITHUB_REF_NAME
```
@ -600,8 +583,7 @@ jobs:
#### Autogenerating the release notes
```yaml
- name: Set versions
id: set-versions
- name: Set environment variables
run: |
version=$(...) <-- get the current version (the one that is being released)
if [[ $version =~ ([0-9]+).([0-9]+).([0-9]+) ]]; then
@ -623,13 +605,11 @@ jobs:
else
prior_version="$major.$minor.$((patch - 1))"
fi
echo "::set-output name=release-version::$version"
echo "::set-output name=prior-release-version::$prior_version"
echo "VERSION=$version" >> $GITHUB_ENV
echo "PRIOR_VERSION=$prior_version" >> $GITHUB_ENV
- name: Generate release notes
env:
VERSION: ${{ steps.set-versions.outputs.release-version }}
PRIOR_VERSION: ${{ steps.set-versions.outputs.prior-release-version }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
if [[ $version != *.0 ]]; then
@ -640,12 +620,12 @@ jobs:
fi
# TODO this is dependent on the conventions you follow in your CHANGELOG.md
sed -n '/^## Version $VERSION/,/^## Version /p' CHANGELOG.md \
sed -n "/^## Version $VERSION/,/^## Version /p" CHANGELOG.md \
| tail -n +2 \
| head -n -1 \
| perl -0pe 's/^\n+//g' \
| perl -0pe 's/\n+$/\n/g' \
| sed -r 's,\[#([0-9]+)]\(https://github.com/$GITHUB_REPOSITORY/(pull|issues)/[0-9]+\),#\1,' \
| sed -r "s,\[#([0-9]+)]\(https://github.com/$GITHUB_REPOSITORY/(pull|issues)/[0-9]+\),#\1," \
| perl -0pe 's/\n +/ /g' \
>> release-notes.txt
```
@ -662,7 +642,6 @@ hitting the "Publish release" button).
```yaml
- name: Create GitHub release
env:
VERSION: ${{ steps.set-versions.outputs.release-version }}
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
gh release create --target $GITHUB_REF_NAME \
@ -672,6 +651,52 @@ hitting the "Publish release" button).
v$VERSION
```
#### Sending a pull request to another repository
For example to send a PR to notify/update another repository that a new release is available.
```yaml
- uses: actions/checkout@v3
with:
repository: opentelemetry-java-bot/opentelemetry-operator
# this is the PAT used for "git push" below
token: ${{ secrets.OPENTELEMETRY_JAVA_BOT_TOKEN }}
- name: Initialize pull request branch
run: |
git remote add upstream https://github.com/open-telemetry/opentelemetry-operator.git
git fetch upstream
git checkout -b update-opentelemetry-javaagent-to-$VERSION upstream/main
- name: Bump version
run: |
echo $VERSION > autoinstrumentation/java/version.txt
- name: Set git user
run: |
git config user.name opentelemetry-java-bot
git config user.email 97938252+opentelemetry-java-bot@users.noreply.github.com
- name: Create pull request against opentelemetry-operator
env:
# this is the PAT used for "gh pr create" below
GITHUB_TOKEN: ${{ secrets.OPENTELEMETRY_JAVA_BOT_TOKEN }}
run: |
msg="Update opentelemetry-javaagent version to $VERSION"
git commit -a -m "$msg"
# gh pr create doesn't have a way to explicitly specify different head and base
# repositories currently, but it will implicitly pick up the head from a different
# repository if you set up a tracking branch
git push --set-upstream origin update-opentelemetry-javaagent-to-$VERSION
gh pr create --title "$msg" \
--body "$msg" \
--repo open-telemetry/opentelemetry-operator
--base main
```
#### Merge back any change log updates to the `main` branch
After the release completes, generate a pull request against the `main` branch to merge back any change log

1
settings.gradle.kts
View File

@ -4,7 +4,6 @@ pluginManagement {
id("com.github.johnrengelman.shadow") version "7.1.2"
id("com.gradle.enterprise") version "3.8.1"
id("io.github.gradle-nexus.publish-plugin") version "1.1.0"
id("nebula.release") version "16.0.0"
id("org.jetbrains.kotlin.jvm") version "1.6.10"
}
}

8
version.gradle.kts Normal file
View File

@ -0,0 +1,8 @@
allprojects {
val release = findProperty("otel.release")
if (release != null) {
version = "1.13.0-" + release + "-SNAPSHOT"
} else {
version = "1.13.0-SNAPSHOT"
}
}