Using @elastic/synthetics to run uptime e2e tests

.ci/end2end.groovy

@@ -13,8 +13,12 @@ pipeline {
     BASE_DIR = 'src/github.com/elastic/kibana'
     HOME = "${env.WORKSPACE}"
     E2E_DIR = 'x-pack/plugins/apm/e2e'
+    UPTIME_E2E_DIR = 'x-pack/plugins/uptime/e2e'
     PIPELINE_LOG_LEVEL = 'INFO'
     KBN_OPTIMIZER_THEMES = 'v7light'
+    GITHUB_CHECK_APM_UI = 'end2end-for-apm-ui'
+    GITHUB_CHECK_UPTIME_UI = 'end2end-for-uptime-ui'
+    GCS_UPLOAD_PREFIX = 'prefix' // forced to set the variable even though it's not required in this pipeline (https://github.com/elastic/kibana/pull/52449)
   }
   options {
     timeout(time: 1, unit: 'HOURS')
@@ -37,93 +41,195 @@ pipeline {
         deleteDir()
         gitCheckout(basedir: "${BASE_DIR}", githubNotifyFirstTimeContributor: false,
                     shallow: false, reference: "/var/lib/jenkins/.git-references/kibana.git")
-
-        // Filter when to run based on the below reasons:
-        //  - On a PRs when:
-        //    - There are changes related to the APM UI project
-        //      - only when the owners of those changes are members of the given GitHub teams
-        //  - On merges to branches when:
-        //    - There are changes related to the APM UI project
-        //  - FORCE parameter is set to true.
-        script {
-          def apm_updated = false
-          dir("${BASE_DIR}"){
-            apm_updated = isGitRegionMatch(patterns: [ "^x-pack/plugins/apm/.*" ])
-          }
-          if (isPR()) {
-            def isMember = isMemberOf(user: env.CHANGE_AUTHOR, team: ['apm-ui', 'uptime'])
-            setEnvVar('RUN_APM_E2E', params.FORCE || (apm_updated && isMember))
-          } else {
-            setEnvVar('RUN_APM_E2E', params.FORCE || apm_updated)
-          }
-        }
+        setEnvVar('RUN_APM_E2E', (params.FORCE || analyseBuildReasonForApmUI()))
+        setEnvVar('RUN_UPTIME_E2E', (params.FORCE || analyseBuildReasonForUptimeUI()))
       }
     }
-    stage('Prepare Kibana') {
-      options { skipDefaultCheckout() }
-      when { expression { return env.RUN_APM_E2E != "false" } }
-      environment {
-        JENKINS_NODE_COOKIE = 'dontKillMe'
-      }
-      steps {
-        notifyStatus('Preparing kibana', 'PENDING')
-        dir("${BASE_DIR}"){
-          sh "${E2E_DIR}/ci/prepare-kibana.sh"
-        }
-      }
-      post {
-        unsuccessful {
-          notifyStatus('Kibana warm up failed', 'FAILURE')
+    stage('e2e') {
+      when {
+        anyOf {
+          expression { return env.RUN_APM_E2E != "false" }
+          expression { return env.RUN_UPTIME_E2E != "false" }
         }
       }
-    }
-    stage('Smoke Tests'){
-      options { skipDefaultCheckout() }
-      when { expression { return env.RUN_APM_E2E != "false" } }
-      steps{
-        notifyTestStatus('Running smoke tests', 'PENDING')
-        dir("${BASE_DIR}"){
-          sh "${E2E_DIR}/ci/run-e2e.sh"
-        }
-      }
-      post {
-        always {
-          dir("${BASE_DIR}/${E2E_DIR}"){
-            archiveArtifacts(allowEmptyArchive: false, artifacts: 'cypress/screenshots/**,cypress/videos/**,cypress/test-results/*e2e-tests.xml')
-            junit(allowEmptyResults: true, testResults: 'cypress/test-results/*e2e-tests.xml')
-            dir('tmp/apm-integration-testing'){
-              sh 'docker-compose logs > apm-its-docker.log || true'
-              sh 'docker-compose down -v || true'
-              archiveArtifacts(allowEmptyArchive: true, artifacts: 'apm-its-docker.log')
+      parallel {
+        stage('APM-UI') {
+          // This stage reuses the top-level agent
+          stages {
+            stage('Prepare build context') {
+              options { skipDefaultCheckout() }
+              steps {
+                pipelineManager([ cancelPreviousRunningBuilds: [ when: 'PR' ] ])
+              }
+            }
+            stage('Prepare Kibana') {
+              options { skipDefaultCheckout() }
+              when { expression { return env.RUN_APM_E2E != "false" } }
+              environment {
+                JENKINS_NODE_COOKIE = 'dontKillMe'
+              }
+              steps {
+                notifyStatus(env.GITHUB_CHECK_APM_UI, 'Preparing kibana', 'PENDING')
+                dir("${BASE_DIR}"){
+                  sh "${E2E_DIR}/ci/prepare-kibana.sh"
+                }
+              }
+              post {
+                unsuccessful {
+                  notifyStatus(env.GITHUB_CHECK_APM_UI, 'Kibana warm up failed', 'FAILURE')
+                }
+              }
+            }
+            stage('Smoke Tests'){
+              options { skipDefaultCheckout() }
+              when { expression { return env.RUN_APM_E2E != "false" } }
+              steps{
+                notifyTestStatus(env.GITHUB_CHECK_APM_UI, 'Running smoke tests', 'PENDING')
+                dir("${BASE_DIR}"){
+                  sh "${E2E_DIR}/ci/run-e2e.sh"
+                }
+              }
+              post {
+                always {
+                  dir("${BASE_DIR}/${E2E_DIR}"){
+                    archiveArtifacts(allowEmptyArchive: false, artifacts: 'cypress/screenshots/**,cypress/videos/**,cypress/test-results/*e2e-tests.xml')
+                    junit(allowEmptyResults: true, testResults: 'cypress/test-results/*e2e-tests.xml')
+                    dir('tmp/apm-integration-testing'){
+                      sh 'docker-compose logs > apm-its-docker.log || true'
+                      sh 'docker-compose down -v || true'
+                      archiveArtifacts(allowEmptyArchive: true, artifacts: 'apm-its-docker.log')
+                    }
+                    archiveArtifacts(allowEmptyArchive: true, artifacts: 'tmp/*.log')
+                  }
+                }
+                unsuccessful {
+                  notifyTestStatus(env.GITHUB_CHECK_APM_UI, 'Test failures', 'FAILURE')
+                }
+                success {
+                  notifyTestStatus(env.GITHUB_CHECK_APM_UI, 'Tests passed', 'SUCCESS')
+                }
+              }
+            }
+          }
+          post {
+            always {
+              dir("${BASE_DIR}"){
+                archiveArtifacts(allowEmptyArchive: true, artifacts: "${E2E_DIR}/kibana.log")
+              }
             }
-            archiveArtifacts(allowEmptyArchive: true, artifacts: 'tmp/*.log')
           }
         }
-        unsuccessful {
-          notifyTestStatus('Test failures', 'FAILURE')
-        }
-        success {
-          notifyTestStatus('Tests passed', 'SUCCESS')
+        stage('UPTIME-UI') {
+          // This stage requires a new agent
+          agent { label 'linux && immutable' }
+          options { skipDefaultCheckout() }
+          when { expression { return env.RUN_UPTIME_E2E != "false" } }
+          stages {
+            stage('Prepare build context') {
+              options { skipDefaultCheckout() }
+              steps {
+                pipelineManager([ cancelPreviousRunningBuilds: [ when: 'PR' ] ])
+                deleteDir()
+                gitCheckout(basedir: "${BASE_DIR}", githubNotifyFirstTimeContributor: false,
+                            shallow: false, reference: "/var/lib/jenkins/.git-references/kibana.git")
+              }
+            }
+            stage('Prepare Kibana') {
+              options { skipDefaultCheckout() }
+              environment {
+                JENKINS_NODE_COOKIE = 'dontKillMe'
+              }
+              steps {
+                notifyStatus(env.GITHUB_CHECK_UPTIME_UI, 'Preparing kibana', 'PENDING')
+                dir("${BASE_DIR}"){
+                  sh "${UPTIME_E2E_DIR}/ci/prepare_kibana.sh"
+                }
+              }
+              post {
+                unsuccessful {
+                  notifyStatus(env.GITHUB_CHECK_UPTIME_UI, 'Kibana warm up failed', 'FAILURE')
+                }
+              }
+            }
+            stage('Smoke Tests'){
+              options { skipDefaultCheckout() }
+              steps{
+                notifyTestStatus(env.GITHUB_CHECK_UPTIME_UI, 'Running smoke tests', 'PENDING')
+                dir("${BASE_DIR}"){
+                  sh "${UPTIME_E2E_DIR}/ci/run_e2e.sh"
+                }
+              }
+              post {
+                always {
+                  dir("${UPTIME_E2E_DIR}"){
+                    sh 'docker-compose logs > uptime-e2e-docker.log || true'
+                    archiveArtifacts(allowEmptyArchive: true, artifacts: 'uptime-e2e-docker.log')
+                  }
+                  echo 'TBD: archive test output when the smoke tests generate junit output'
+                }
+                unsuccessful {
+                  notifyTestStatus(env.GITHUB_CHECK_UPTIME_UI, 'Test failures', 'FAILURE')
+                }
+                success {
+                  notifyTestStatus(env.GITHUB_CHECK_UPTIME_UI, 'Tests passed', 'SUCCESS')
+                }
+              }
+            }
+          }
+          post {
+            always {
+              dir("${BASE_DIR}"){
+                archiveArtifacts(allowEmptyArchive: true, artifacts: "${UPTIME_E2E_DIR}/kibana.log")
+              }
+            }
+          }
         }
       }
     }
   }
   post {
-    always {
-      dir("${BASE_DIR}"){
-        archiveArtifacts(allowEmptyArchive: true, artifacts: "${E2E_DIR}/kibana.log")
-      }
-    }
     cleanup {
       notifyBuildResult(prComment: false, analyzeFlakey: false, shouldNotify: false)
     }
   }
 }
 
-def notifyStatus(String description, String status) {
-  withGithubStatus.notify('end2end-for-apm-ui', description, status, getBlueoceanTabURL('pipeline'))
+def notifyStatus(String check, String description, String status) {
+  withGithubStatus.notify(check, description, status, getBlueoceanTabURL('pipeline'))
 }
 
-def notifyTestStatus(String description, String status) {
-  withGithubStatus.notify('end2end-for-apm-ui', description, status, getBlueoceanTabURL('tests'))
+def notifyTestStatus(String check, String description, String status) {
+  withGithubStatus.notify(check, description, status, getBlueoceanTabURL('tests'))
+}
+
+def analyseBuildReasonForApmUI() {
+  return shouldTriggerABuild(patterns: [ "^x-pack/plugins/apm/.*" ], team: ['apm-ui', 'uptime'])
+}
+
+def analyseBuildReasonForUptimeUI() {
+  return shouldTriggerABuild(patterns: [ "^x-pack/plugins/uptime/.*" ], team: ['uptime'])
+}
+
+/**
+* Filter when to run based on the below reasons:
+*  - On a PRs when:
+*    - There are changes related to the given subfolder
+*      - only when the owners of those changes are members of the given GitHub teams
+*  - On merges to branches when:
+*    - There are changes related to the given subfolder
+*  - FORCE parameter is set to true.
+*/
+def shouldTriggerABuild(Map args = [:]) {
+  def patterns = args.patterns
+  def team = args.team
+  def updated = false
+  dir("${BASE_DIR}"){
+    updated = isGitRegionMatch(patterns: patterns)
+  }
+  if (isPR()) {
+    def isMember = isMemberOf(user: env.CHANGE_AUTHOR, team: team)
+    return (params.FORCE || (updated && isMember))
+  } else {
+    return (params.FORCE || apm_updated)
+  }
 }

package.json

@@ -454,6 +454,7 @@
     "@elastic/eslint-plugin-eui": "0.0.2",
     "@elastic/github-checks-reporter": "0.0.20b3",
     "@elastic/makelogs": "^6.0.0",
+    "@elastic/synthetics": "^1.0.0-beta.8",
     "@istanbuljs/schema": "^0.1.2",
     "@jest/reporters": "^26.6.2",
     "@kbn/babel-code-parser": "link:bazel-bin/packages/kbn-babel-code-parser",

src/dev/typescript/projects.ts

@@ -34,6 +34,11 @@ export const PROJECTS = [
     disableTypeCheck: true,
   }),
 
+  new Project(resolve(REPO_ROOT, 'x-pack/plugins/uptime/e2e/tsconfig.json'), {
+    name: 'uptime/synthetics-e2e-tests',
+    disableTypeCheck: true,
+  }),
+
   // NOTE: using glob.sync rather than glob-all or globby
   // because it takes less than 10 ms, while the other modules
   // both took closer to 1000ms.

x-pack/package.json

@@ -25,4 +25,4 @@
   "engines": {
     "yarn": "^1.21.1"
   }
-}
+}

x-pack/plugins/uptime/e2e/ci/prepare_kibana.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -e
+
+UPTIME_DIR=x-pack/plugins/uptime
+echo "1/2 Install dependencies..."
+# shellcheck disable=SC1091
+source src/dev/ci_setup/setup_env.sh true
+yarn kbn bootstrap
+
+echo "2/2 Start Kibana..."
+## Might help to avoid FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
+export NODE_OPTIONS="--max-old-space-size=4096"
+cd $UPTIME_DIR
+nohup node ./scripts/start_e2e_server.js > e2e/kibana.log 2>&1 &

x-pack/plugins/uptime/e2e/ci/run_e2e.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+##
+## This is a wrapper to configure the environment with the right tools in the CI
+## and run the e2e steps.
+##
+
+# shellcheck disable=SC1091
+source src/dev/ci_setup/setup_env.sh true
+set -e
+
+# variables
+KIBANA_PORT=5620
+
+# formatting
+bold=$(tput bold)
+normal=$(tput sgr0)
+
+# paths
+E2E_DIR="${0%/*}/../.."
+
+cd "${E2E_DIR}"
+
+#
+# Ask user to start Kibana
+##################################################
+echo "" # newline
+echo "${bold}To start Kibana please run the following command:${normal}
+node ./scripts/start_e2e_server.js"
+
+echo "✅ Setup completed successfully. Running tests..."
+node ./scripts/start_e2e_runner.js
+e2e_status=$?
+
+# Report the e2e status at the very end
+if [ $e2e_status -ne 0 ]; then
+    echo "⚠️  Running tests failed."
+    exit 1
+fi