elastic-apm 3.5.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50ba0e1480f379488014123efe0974b22741593d451f1a501390dd0f8af17be2
-  data.tar.gz: f448574e08404ef0354998ef7e87173e653ef837309a3114f8694dcae97dbae3
+  metadata.gz: e9c3bd29131a80fd061ecda5285eaf367f1e5643a5d6bd27b753fb566fa51799
+  data.tar.gz: 51b05bac2568d0c55f83444cef9f297400078a7cbcb0fef6c6ef4ce9cfdfe2fa
 SHA512:
-  metadata.gz: d7a730f4a97d7c974fa6f8d4acd5f5d5274f552eeeaacf169d2feb27e19b0b8ac1959df2cd8efa7718517cdf7bd1f81ad6e09d3fc57bba1f96d48b5c7572c472
-  data.tar.gz: 0e695ab76052b342ae71ba7e4eed6a6a03f1368ac67638fbc3a4e8ef2c1558e183d3911eeb38aba296d4ae469f37c4665123f4fe204760ce9f74dcdc238150ee
+  metadata.gz: db6319dbfcbe5f2429c72aebb8132bc9d1a35b4ec28aa15ecd1bb06fff4a326ad41f4753a3fb54f6f85635d9429d434f4f30b2ea23013cf7e775cb6f2d3a8a23
+  data.tar.gz: 32f64b02b56d214a019279b84bdaa3b04f6d72fac06d664326d0939c16c0b50a05b3654ae87a68a057c17c576679cbc726dd890cde2ac1068dd7a0fbbb05b030

data/.ci/Jenkinsfile

@@ -5,21 +5,17 @@ import co.elastic.matrix.*
 import groovy.transform.Field
 
 /**
- This is required to know if there any failures when running the downstream jobs.
+This is the parallel tasks generator,
+it is need as field to store the results of the tests.
 */
-@Field def rubyTasksFailed = false
-
-/**
- This is required to store the build status for the downstream jobs.
-*/
-@Field def rubyDownstreamJobs = [:]
+@Field def rubyTasksGen
 
 pipeline {
   agent { label 'linux && immutable' }
   environment {
     REPO = 'apm-agent-ruby'
     BASE_DIR = "src/github.com/elastic/${env.REPO}"
-    PIPELINE_LOG_LEVEL='DEBUG'
+    PIPELINE_LOG_LEVEL = 'INFO'
     NOTIFY_TO = credentials('notify-to')
     JOB_GCS_BUCKET = credentials('gcs-bucket')
     CODECOV_SECRET = 'secret/apm-team/ci/apm-agent-ruby-codecov'
@@ -42,7 +38,7 @@ pipeline {
     quietPeriod(10)
   }
   triggers {
-    issueCommentTrigger('(?i).*(?:jenkins\\W+)?run\\W+(?:the\\W+)?tests(?:\\W+please)?.*')
+    issueCommentTrigger('(?i).*(?:jenkins\\W+)?run\\W+(?:the\\W+)?(?:benchmark\\W+)?tests(?:\\W+please)?.*')
   }
   parameters {
     booleanParam(name: 'Run_As_Master_Branch', defaultValue: false, description: 'Allow to run any steps on a PR, some steps normally only run on master branch.')
@@ -59,14 +55,23 @@ pipeline {
         deleteDir()
         gitCheckout(basedir: "${BASE_DIR}", githubNotifyFirstTimeContributor: true, reference: "${env.REFERENCE_REPO}")
         stash allowEmpty: true, name: 'source', useDefaultExcludes: false
+        script {
+          dir("${BASE_DIR}"){
+            // Skip all the stages except docs for PR's with asciidoc and md changes only
+            env.ONLY_DOCS = isGitRegionMatch(patterns: [ '.*\\.(asciidoc|md)' ], shouldMatchAll: true)
+          }
+        }
       }
     }
     stage('Sanity checks') {
       when {
         beforeAgent true
-        anyOf {
-          not { changeRequest() }
-          expression { return params.Run_As_Master_Branch }
+        allOf {
+          expression { return env.ONLY_DOCS == "false" }
+          anyOf {
+            not { changeRequest() }
+            expression { return params.Run_As_Master_Branch }
+          }
         }
       }
       options { skipDefaultCheckout() }
@@ -89,173 +94,177 @@ pipeline {
     /**
     Execute unit tests.
     */
-    stage('Test') {
-      options { skipDefaultCheckout() }
-      steps {
-        withGithubNotify(context: 'Tests', tab: 'tests') {
-          deleteDir()
-          unstash "source"
-          dir("${BASE_DIR}"){
-            script {
-              def ruby = readYaml(file: '.ci/.jenkins_ruby.yml')
-              def testTasks = [:]
-              def i = 0
-              ruby['RUBY_VERSION'].each{ rubyVersion ->
-                testTasks[rubyVersion] = { runJob(rubyVersion, i++) }
-              }
-              parallel(testTasks)
-              }
-            }
-          }
-        }
+    stage('Tests') {
+      when {
+        beforeAgent true
+        expression { return env.ONLY_DOCS == "false" }
       }
-      stage('Benchmarks') {
-        options { skipDefaultCheckout() }
-        when {
-          beforeAgent true
-          allOf {
-            anyOf {
-              branch 'master'
-              branch "\\d+\\.\\d+"
-              branch "v\\d?"
-              tag "v\\d+\\.\\d+\\.\\d+*"
-              expression { return params.Run_As_Master_Branch }
+      failFast false
+      parallel {
+        stage('Tests') {
+          options { skipDefaultCheckout() }
+          steps {
+            withGithubNotify(context: 'Tests', tab: 'tests') {
+              runTests('.ci/.jenkins_framework.yml')
             }
-            expression { return params.bench_ci }
           }
-        }
-        stages {
-          stage('Clean Workspace') {
-            agent { label 'metal' }
-            steps {
-              echo "Cleaning Workspace"
-            }
-            post {
-              always {
-                cleanWs()
-              }
+          post {
+            always {
+              convergeCoverage()
             }
           }
-          /**
-            Run the benchmarks and store the results on ES.
-            The result JSON files are also archive into Jenkins.
-          */
-          stage('Run Benchmarks') {
-            steps {
-              withGithubNotify(context: 'Run Benchmarks') {
-                deleteDir()
-                unstash 'source'
-                dir("${BASE_DIR}"){
-                  script {
-                    def versions = readYaml(file: ".ci/.jenkins_ruby.yml")
-                    def benchmarkTask = [:]
-                    versions['RUBY_VERSION'].each{ v ->
-                      benchmarkTask[v] = runBenchmark(v)
-                    }
-                    parallel(benchmarkTask)
-                  }
-                }
-              }
+        }
+        stage('Master Tests frameworks') {
+          options { skipDefaultCheckout() }
+          steps {
+            catchError(buildResult: 'SUCCESS', stageResult: 'UNSTABLE', message: "The tests for the master framework have failed. Let's warn instead.") {
+              runTests('.ci/.jenkins_master_framework.yml')
             }
           }
         }
-      }
-      stage('Populate Downstream failures') {
-        when {
-          expression { return rubyTasksFailed }
-        }
-        steps {
-          script {
-            def message = 'Failures when running the "Test" stage'
-            if (notifyBuildResult.isAnyDownstreamJobFailedWithTimeout(rubyDownstreamJobs)) {
-              message += ' related to a timeout issue'
+        stage('Integration Tests') {
+          agent none
+          when {
+            beforeAgent true
+            anyOf {
+              changeRequest()
+              expression { return !params.Run_As_Master_Branch }
             }
-            error(message)
+          }
+          steps {
+            githubNotify(context: "${env.GITHUB_CHECK_ITS_NAME}", description: "${env.GITHUB_CHECK_ITS_NAME} ...", status: 'PENDING', targetUrl: "${env.JENKINS_URL}search/?q=${env.ITS_PIPELINE.replaceAll('/','+')}")
+            build(job: env.ITS_PIPELINE, propagate: false, wait: true,
+                  parameters: [ string(name: 'INTEGRATION_TEST', value: 'Ruby'),
+                                string(name: 'BUILD_OPTS', value: "--ruby-agent-version ${env.GIT_BASE_COMMIT} --ruby-agent-version-state ${env.GIT_BUILD_CAUSE} --ruby-agent-repo ${env.CHANGE_FORK?.trim() ?: 'elastic'}/${env.REPO} --opbeans-ruby-agent-branch ${env.GIT_BASE_COMMIT}"),
+                                string(name: 'GITHUB_CHECK_NAME', value: env.GITHUB_CHECK_ITS_NAME),
+                                string(name: 'GITHUB_CHECK_REPO', value: env.REPO),
+                                string(name: 'GITHUB_CHECK_SHA1', value: env.GIT_BASE_COMMIT) ])
           }
         }
       }
-      stage('Integration Tests') {
-        agent none
-        when {
-          beforeAgent true
+    }
+    stage('Benchmarks') {
+      options { skipDefaultCheckout() }
+      when {
+        beforeAgent true
+        allOf {
           anyOf {
-            changeRequest()
-            expression { return !params.Run_As_Master_Branch }
+            branch 'master'
+            branch "\\d+\\.\\d+"
+            branch "v\\d?"
+            tag pattern: 'v\\d+.*', comparator: "REGEXP"
+            expression { return params.Run_As_Master_Branch }
+            expression { return env.GITHUB_COMMENT?.contains('benchmark tests') }
           }
-        }
-        steps {
-          log(level: 'INFO', text: 'Launching Async ITs')
-          build(job: env.ITS_PIPELINE, propagate: false, wait: false,
-                parameters: [string(name: 'AGENT_INTEGRATION_TEST', value: 'Ruby'),
-                             string(name: 'BUILD_OPTS', value: "--ruby-agent-version ${env.GIT_BASE_COMMIT} --ruby-agent-version-state ${env.GIT_BUILD_CAUSE} --ruby-agent-repo ${env.CHANGE_FORK?.trim() ?: 'elastic'}/${env.REPO}"),
-                             string(name: 'GITHUB_CHECK_NAME', value: env.GITHUB_CHECK_ITS_NAME),
-                             string(name: 'GITHUB_CHECK_REPO', value: env.REPO),
-                             string(name: 'GITHUB_CHECK_SHA1', value: env.GIT_BASE_COMMIT)]
-          )
-          githubNotify(context: "${env.GITHUB_CHECK_ITS_NAME}", description: "${env.GITHUB_CHECK_ITS_NAME} ...", status: 'PENDING', targetUrl: "${env.JENKINS_URL}search/?q=${env.ITS_PIPELINE.replaceAll('/','+')}")
+          expression { return params.bench_ci }
         }
       }
-      stage('Release') {
-        options { skipDefaultCheckout() }
-        environment {
-          RUBY_DOCKER_TAG = 'ruby:2.6'
-          HOME = '/var/lib/jenkins'
-        }
-        when {
-          beforeAgent true
-          tag pattern: 'v\\d+.*', comparator: 'REGEXP'
+      stages {
+        stage('Clean Workspace') {
+          agent { label 'metal' }
+          steps {
+            echo "Cleaning Workspace"
+          }
+          post {
+            always {
+              cleanWs()
+            }
+          }
         }
-        stages {
-          stage('Release') {
-            steps {
-              withGithubNotify(context: 'Release') {
-                deleteDir()
-                unstash 'source'
+        /**
+          Run the benchmarks and store the results on ES.
+          The result JSON files are also archive into Jenkins.
+        */
+        stage('Run Benchmarks') {
+          steps {
+            withGithubNotify(context: 'Run Benchmarks') {
+              deleteDir()
+              unstash 'source'
+              dir("${BASE_DIR}"){
                 script {
-                  dir(BASE_DIR){
-                    docker.image("${env.RUBY_DOCKER_TAG}").inside('-v ${REFERENCE_REPO}:${REFERENCE_REPO} -v /etc/passwd:/etc/passwd -v ${HOME}/.ssh:${HOME}/.ssh') {
-                      withEnv(["HOME=${env.WORKSPACE}/${env.BASE_DIR ?: ''}"]) {
-                        rubygemsLogin.withApi(secret: "${env.RELEASE_SECRET}") {
-                          sshagent(['f6c7695a-671e-4f4f-a331-acdce44ff9ba']) {
-                            sh '.ci/prepare-git-context.sh'
-                            sh 'gem install rake yard rspec'
-                            sh 'rake release'
-                          }
-                        }
-                      }
-                    }
+                  def versions = readYaml(file: ".ci/.jenkins_ruby.yml")
+                  def benchmarkTask = [:]
+                  versions['RUBY_VERSION'].each{ v ->
+                    benchmarkTask[v] = runBenchmark(v)
                   }
+                  parallel(benchmarkTask)
                 }
               }
             }
           }
-          stage('Opbeans') {
-            environment {
-              REPO_NAME = "${OPBEANS_REPO}"
+        }
+      }
+    }
+    stage('Release') {
+      options { skipDefaultCheckout() }
+      environment {
+        RUBY_DOCKER_TAG = 'ruby:2.6'
+        HOME = '/var/lib/jenkins'
+      }
+      when {
+        beforeAgent true
+        tag pattern: 'v\\d+.*', comparator: 'REGEXP'
+      }
+      stages {
+        stage('Release') {
+          steps {
+            deleteDir()
+            unstash 'source'
+            prepareRelease(){
+              sh 'rake release'
             }
-            steps {
-              deleteDir()
-              dir("${OPBEANS_REPO}"){
-                git credentialsId: 'f6c7695a-671e-4f4f-a331-acdce44ff9ba',
-                    url: "git@github.com:elastic/${OPBEANS_REPO}.git"
-                // It's required to transform the tag value to the gem version
-                sh script: ".ci/bump-version.sh ${env.BRANCH_NAME.replaceAll('^v', '')}", label: 'Bump version'
-                // The opbeans pipeline will trigger a release for the master branch
-                gitPush()
-                // The opbeans pipeline will trigger a release for the release tag
-                gitCreateTag(tag: "${env.BRANCH_NAME}")
+          }
+        }
+        stage('Update Branch') {
+          steps {
+            deleteDir()
+            unstash 'source'
+            prepareRelease(){
+              catchError(buildResult: 'SUCCESS', message: 'Update branch task failed', stageResult: 'UNSTABLE') {
+                sh 'rake release:update_branch'
               }
             }
           }
+          post {
+            unsuccessful {
+              emailext subject: "[${env.REPO}] Syncup post-release stage failed.", to: "${NOTIFY_TO}",
+                        body: "Please go to ${env.BUILD_URL} to review the logs. Most likely you need to update the branch manually."
+            }
+          }
+        }
+        stage('Opbeans') {
+          environment {
+            REPO_NAME = "${OPBEANS_REPO}"
+            VERSION = "${env.BRANCH_NAME.replaceAll('^v', '')}"
+          }
+          steps {
+            deleteDir()
+            // Let's wait for the Gem to be available
+            sh label: 'Wait for gem', script: """#!/usr/bin/env bash
+              source /usr/local/bin/bash_standard_lib.sh
+              (retry 10 curl --silent --show-error --fail -I https://rubygems.org/gems/elastic-apm/versions/${env.VERSION})
+            """
+            dir("${OPBEANS_REPO}"){
+              git credentialsId: 'f6c7695a-671e-4f4f-a331-acdce44ff9ba',
+                  url: "git@github.com:elastic/${OPBEANS_REPO}.git"
+              // It's required to transform the tag value to the gem version
+              sh script: ".ci/bump-version.sh ${env.VERSION}", label: 'Bump version'
+              // The opbeans pipeline will trigger a release for the master branch
+              gitPush()
+              // The opbeans pipeline will trigger a release for the release tag
+              gitCreateTag(tag: "${env.BRANCH_NAME}")
+            }
+          }
         }
       }
     }
-    post {
-      cleanup {
-        notifyBuildResult(downstreamJobs: rubyDownstreamJobs)
-      }
+  }
+  post {
+    cleanup {
+      notifyBuildResult()
     }
   }
+}
 
 /**
   Run benchmarks for a Ruby version, then report the results to the Elasticsearch server.
@@ -267,26 +276,64 @@ def runBenchmark(version){
       //  - docker.elastic.co/observability-ci/jruby:9.2-12-jdk to jruby-9.2-12-jdk
       //  - jruby:9.1 to jruby-9.1
       def transformedVersion = version.replaceAll('.*/', '').replaceAll(':', '-')
-      env.HOME = "${env.WORKSPACE}/${transformedVersion}"
-      dir("${transformedVersion}"){
-        deleteDir()
-        unstash 'source'
-        dir("${BASE_DIR}"){
-          retry(2){
-            sleep randomNumber(min:10, max: 30)
-            dockerLogin(secret: "${DOCKER_SECRET}", registry: "${DOCKER_REGISTRY}")
+      withEnv(["HOME=${env.WORKSPACE}/${transformedVersion}"]){
+        dir("${transformedVersion}"){
+          deleteDir()
+          unstash 'source'
+          dir("${BASE_DIR}"){
+            retry(2){
+              sleep randomNumber(min:10, max: 30)
+              dockerLogin(secret: "${DOCKER_SECRET}", registry: "${DOCKER_REGISTRY}")
+            }
+            try{
+              sh """./spec/scripts/benchmarks.sh "${version}" "${REFERENCE_REPO}" """
+            } catch(e){
+              throw e
+            } finally {
+              archiveArtifacts(
+                allowEmptyArchive: true,
+                artifacts: "**/benchmark-${transformedVersion}.raw,**/benchmark-${transformedVersion}.error",
+                onlyIfSuccessful: false)
+              sendBenchmarks(file: "benchmark-${transformedVersion}.bulk",
+                index: "benchmark-ruby", archive: true)
+            }
           }
-          try{
-            sh """./spec/scripts/benchmarks.sh "${version}" "${REFERENCE_REPO}" """
-          } catch(e){
-            throw e
-          } finally {
-            archiveArtifacts(
-              allowEmptyArchive: true,
-              artifacts: "**/benchmark-${transformedVersion}.raw,**/benchmark-${transformedVersion}.error",
-              onlyIfSuccessful: false)
-            sendBenchmarks(file: "benchmark-${transformedVersion}.bulk",
-              index: "benchmark-ruby", archive: true)
+        }
+      }
+    }
+  }
+}
+
+class RubyParallelTaskGenerator extends DefaultParallelTaskGenerator {
+
+  public RubyParallelTaskGenerator(Map params){
+    super(params)
+  }
+
+  /**
+  build a clousure that launch and agent and execute the corresponding test script,
+  then store the results.
+  */
+  public Closure generateStep(x, y){
+    return {
+      steps.sleep steps.randomNumber(min:10, max: 30)
+      steps.node('linux && immutable'){
+        // Label is transformed to avoid using the internal docker registry in the x coordinate
+        // TODO: def label = "${tag}:${x?.drop(x?.lastIndexOf('/')+1)}#${y}"
+        def label = "${tag}:${x}#${y}"
+        try {
+          steps.runScript(label: label, ruby: x, framework: y)
+          saveResult(x, y, 1)
+        } catch(e){
+          saveResult(x, y, 0)
+          steps.error("${label} tests failed : ${e.toString()}\n")
+        } finally {
+          steps.junit(allowEmptyResults: false,
+            keepLongStdio: true,
+            testResults: "**/spec/junit-reports/**/ruby-agent-junit.xml")
+          steps.dir("${steps.env.BASE_DIR}"){
+            steps.archiveArtifacts(artifacts: 'coverage/matrix_results/', defaultExcludes: false)
+            steps.stash(name: steps.normalise("coverage-${x}-${y}"), includes: 'coverage/matrix_results/', allowEmpty: true)
           }
         }
       }
@@ -294,23 +341,79 @@ def runBenchmark(version){
   }
 }
 
-def runJob(String rubyVersion, int sleep = 1){
-  def buildObject
-  try {
-    def quiet = (sleep * randomNumber(min: 2, max: 6)) + 5
-    buildObject = build(job: "apm-agent-ruby/apm-agent-ruby-downstream/${env.BRANCH_NAME}",
-                        parameters: [
-                          string(name: 'RUBY_VERSION', value: "${rubyVersion}"),
-                          string(name: 'BRANCH_SPECIFIER', value: "${env.GIT_BASE_COMMIT}")
-                        ],
-                        quietPeriod: quiet)
-  } catch(e) {
-    rubyTasksFailed = true
-    buildObject = e
-    warnError('Downstream Failed') {
-      error("Downstream job for '${rubyVersion}' failed")
+/**
+  Run all the tests for the given file with the frameworks to test
+*/
+def runTests(frameworkFile) {
+  deleteDir()
+  unstash "source"
+  dir("${BASE_DIR}"){
+    rubyTasksGen = new RubyParallelTaskGenerator(
+      xKey: 'RUBY_VERSION',
+      yKey: 'FRAMEWORK',
+      xFile: ".ci/.jenkins_ruby.yml",
+      yFile: frameworkFile,
+      exclusionFile: ".ci/.jenkins_exclude.yml",
+      tag: "Ruby",
+      name: "Ruby",
+      steps: this
+    )
+    def testTasks = rubyTasksGen.generateParallelTests()
+    parallel(testTasks)
+  }
+}
+
+/**
+  Run tests for a Ruby version and framework version.
+*/
+def runScript(Map params = [:]){
+  def label = params.label
+  def ruby = params.ruby
+  def framework = params.framework
+  log(level: 'INFO', text: "${label}")
+  retry(2){
+    withEnv(["HOME=${env.WORKSPACE}", "PATH=${env.PATH}:${env.WORKSPACE}/bin"]) {
+      deleteDir()
+      unstash 'source'
+      dir("${BASE_DIR}"){
+        sleep randomNumber(min:10, max: 30)
+        dockerLogin(secret: "${DOCKER_SECRET}", registry: "${DOCKER_REGISTRY}")
+        sh("./spec/scripts/spec.sh ${ruby} ${framework}")
+      }
+    }
+  }
+}
+
+def convergeCoverage() {
+  deleteDir()
+  unstash('source')
+  dir("${BASE_DIR}"){
+    rubyTasksGen.dumpMatrix('-')?.each {
+      unstash(normalise("coverage-${it}"))
+    }
+    sh(script: './spec/scripts/coverage_converge.sh')
+    cobertura coberturaReportFile: 'coverage/coverage.xml', onlyStable: false
+  }
+}
+
+def prepareRelease(Closure body){
+  dir("${env.BASE_DIR}"){
+    docker.image("${env.RUBY_DOCKER_TAG}").inside('-v ${REFERENCE_REPO}:${REFERENCE_REPO} -v /etc/passwd:/etc/passwd -v ${HOME}/.ssh:${HOME}/.ssh') {
+      withEnv(["HOME=${env.WORKSPACE}/${env.BASE_DIR ?: ''}"]) {
+        rubygemsLogin.withApi(secret: "${env.RELEASE_SECRET}") {
+          withGitRelease(credentialsId: '2a9602aa-ab9f-4e52-baf3-b71ca88469c7-UserAndToken') {
+            sh 'gem install rake yard rspec'
+            body()
+          }
+        }
+      }
     }
-  } finally {
-    rubyDownstreamJobs["${rubyVersion}"] = buildObject
   }
 }
+
+// Transform the versions like:
+//  - docker.elastic.co/observability-ci/jruby:9.2-12-jdk to jruby-9.2-12-jdk
+//  - jruby:9.1 to jruby-9.1
+def normalise(def what) {
+  return what.replaceAll('.*/', '').replaceAll(':', '-')
+}