From aa45c2aee36932f2410b2247de0b40d6c387652f Mon Sep 17 00:00:00 2001 From: Dzmitry Lemechko Date: Tue, 19 Mar 2024 00:42:45 +0100 Subject: [PATCH] [kbn-journeys] add synthtrace support (#178599) ## Summary Moving synthtrace clients init inside kbn-journeys: esArchiver does not always solve the issue with data generation. We already have afew journeys using Synthtrace instead and expect more to come. In order to simplify the process of creating new journeys, this PR moves Synthtrace client initialisation into kbn-journey package and exposes a way to define client type, generator function & its input arguments: ``` import { Journey, SynthtraceOptions } from '@kbn/journeys'; import { subj } from '@kbn/test-subj-selector'; import { generateApmData } from '../synthtrace_data/apm_data'; export const journey = new Journey({ synthtrace: { type: 'apm', generator: generateApmData, options: { from: new Date(Date.now() - 1000 * 60 * 15), to: new Date(Date.now() + 1000 * 60 * 15), }, }, }) ``` PR also needs review from teams who use Synthtrace to understand if the implementation is matching expectations. --------- Co-authored-by: kibanamachine <42973632+kibanamachine@users.noreply.github.com> --- .../adding_performance_journey.mdx | 28 +++- .../kbn-journeys/journey/journey_config.ts | 31 ++++- .../journey/journey_ftr_harness.ts | 60 ++++++++- packages/kbn-journeys/kibana.jsonc | 2 +- packages/kbn-journeys/services/synthtrace.ts | 123 ++++++++++++++++++ packages/kbn-journeys/tsconfig.json | 2 + .../kibana.jsonc | 2 +- .../journeys_e2e/apm_service_inventory.ts | 35 ++--- .../journeys_e2e/infra_hosts_view.ts | 72 ++-------- .../performance/services/synthtrace/index.ts | 66 ---------- .../performance/synthtrace_data/apm_data.ts | 9 +- .../performance/synthtrace_data/hosts_data.ts | 37 ++++++ x-pack/performance/tsconfig.json | 1 - 13 files changed, 297 insertions(+), 171 deletions(-) create mode 100644 packages/kbn-journeys/services/synthtrace.ts delete mode 100644 x-pack/performance/services/synthtrace/index.ts create mode 100644 x-pack/performance/synthtrace_data/hosts_data.ts diff --git a/dev_docs/tutorials/performance/adding_performance_journey.mdx b/dev_docs/tutorials/performance/adding_performance_journey.mdx index 88b188f555028..2f7f37452c285 100644 --- a/dev_docs/tutorials/performance/adding_performance_journey.mdx +++ b/dev_docs/tutorials/performance/adding_performance_journey.mdx @@ -8,6 +8,7 @@ tags: ['kibana', 'onboarding', 'setup', 'performance', 'development'] --- ## Overview + In order to achieve our goal of creating best user experience in Kibana, it is important to keep track on its features performance. To make things easier, we introduced performance journeys, that mimics end-user experience with Kibana. @@ -19,6 +20,7 @@ Journeys core is [kbn-journeys](packages/kbn-journeys/README.mdx) package. It is by [Playwright](https://playwright.dev/) end-to-end testing tool. ### Adding a new performance journey + Let's assume we instrumented dashboard with load time metrics and want to track sample data flights dashboard performance. Journey supports loading test data with esArchiver or kbnArchiver. Similar to functional tests, it might require to implement custom wait for UI rendering to be completed. @@ -42,18 +44,36 @@ export const journey = new Journey({ }); ``` +Alternative to archives is to use Synthtrace ES client: + +``` +export const journey = new Journey({ + synthtrace: { + type: 'apm', + generator: generateApmData, + options: { + from: new Date(Date.now() - 1000 * 60 * 15), + to: new Date(Date.now() + 1000 * 60 * 15), + }, + }, +}) +``` + In oder to get correct and consistent metrics, it is important to design journey properly: -- use archives to generate test data + +- use archives or synthtrace to generate test data - decouple complex scenarios into multiple simple journeys - use waiting for page loading / UI component rendering - test locally and check if journey is stable. - make sure performance metrics are collected on every run. ### Running performance journey locally for troubleshooting purposes + Use the Node script: - `node scripts/run_performance.js --journey-path x-pack/performance/journeys_e2e/$YOUR_JOURNEY_NAME.ts` +`node scripts/run_performance.js --journey-path x-pack/performance/journeys_e2e/$YOUR_JOURNEY_NAME.ts` Scripts steps include: + - start Elasticsearch - start Kibana and run journey first time (warmup) only APM metrics being reported - start Kibana and run journey second time (test): both EBT and APM metrics being reported @@ -65,6 +85,7 @@ Since the tests are run on a local machine, there is also realistic throttling a simulate real life internet connection. This means that all requests have a fixed latency and limited bandwidth. ### Benchmarking performance on CI + In order to keep track on performance metrics stability, journeys are run on main branch with a scheduled interval. Bare metal machine is used to produce results as stable and reproducible as possible. @@ -77,9 +98,8 @@ RAM: 128 GB SSD: 1.92 TB Data center Gen4 NVMe #### Track performance results + APM metrics are reported to [kibana-ops-e2e-perf](https://kibana-ops-e2e-perf.kb.us-central1.gcp.cloud.es.io/) cluster. You can filter transactions using labels, e.g. `labels.journeyName : "flight_dashboard"` Custom metrics reported with EBT are available in [Telemetry Staging](https://telemetry-v2-staging.elastic.dev/) cluster, `kibana-performance` space. - - diff --git a/packages/kbn-journeys/journey/journey_config.ts b/packages/kbn-journeys/journey/journey_config.ts index 2587a4dcbe522..98b39b8ce37ab 100644 --- a/packages/kbn-journeys/journey/journey_config.ts +++ b/packages/kbn-journeys/journey/journey_config.ts @@ -10,7 +10,16 @@ import Path from 'path'; import { REPO_ROOT } from '@kbn/repo-info'; +import { SynthtraceGenerator } from '@kbn/apm-synthtrace-client/src/types'; +import { Readable } from 'stream'; import { BaseStepCtx } from './journey'; +import { SynthtraceClientType } from '../services/synthtrace'; + +interface JourneySynthtrace { + type: SynthtraceClientType; + generator: (options: O) => Readable | SynthtraceGenerator; + options: O; +} export interface RampConcurrentUsersAction { action: 'rampConcurrentUsers'; @@ -69,7 +78,7 @@ export interface ScalabilitySetup { test: ScalabilityAction[]; } -export interface JourneyConfigOptions { +export interface JourneyConfigOptions { /** * Relative path to FTR config file. Use to override the default ones: * 'x-pack/test/functional/config.base.js', 'test/functional/config.base.js' @@ -116,9 +125,23 @@ export interface JourneyConfigOptions { extendContext?: (ctx: BaseStepCtx) => CtxExt; /** * Use this to define actions that will be executed after Kibana & ES were started, - * but before archives are loaded. APM traces are not collected for this hook. + * but before archives are loaded or synthtrace is run. APM traces are not collected for this hook. */ beforeSteps?: (ctx: BaseStepCtx & CtxExt) => Promise; + /** + * Use to setup ES data ingestion with APM Synthtrace + * + * synthtrace: { + * type: 'infra', + * generator: generateHostsData, + * options: { + * from: new Date(Date.now() - 1000 * 60 * 10), + * to: new Date(), + * count: 1000, + * }, + * }, + */ + synthtrace?: JourneySynthtrace; } export class JourneyConfig { @@ -192,4 +215,8 @@ export class JourneyConfig { new Promise((resolve) => resolve()); } } + + getSynthtraceConfig() { + return this.#opts.synthtrace; + } } diff --git a/packages/kbn-journeys/journey/journey_ftr_harness.ts b/packages/kbn-journeys/journey/journey_ftr_harness.ts index 4b1a69757067e..a2657646954a8 100644 --- a/packages/kbn-journeys/journey/journey_ftr_harness.ts +++ b/packages/kbn-journeys/journey/journey_ftr_harness.ts @@ -29,9 +29,11 @@ import type { Step, AnyStep } from './journey'; import type { JourneyConfig } from './journey_config'; import { JourneyScreenshots } from './journey_screenshots'; import { getNewPageObject } from '../services/page'; +import { getSynthtraceClient } from '../services/synthtrace'; export class JourneyFtrHarness { private readonly screenshots: JourneyScreenshots; + private readonly kbnUrl: KibanaUrl; constructor( private readonly log: ToolingLog, @@ -44,6 +46,15 @@ export class JourneyFtrHarness { private readonly journeyConfig: JourneyConfig ) { this.screenshots = new JourneyScreenshots(this.journeyConfig.getName()); + this.kbnUrl = new KibanaUrl( + new URL( + Url.format({ + protocol: this.config.get('servers.kibana.protocol'), + hostname: this.config.get('servers.kibana.hostname'), + port: this.config.get('servers.kibana.port'), + }) + ) + ); } private browser: ChromiumBrowser | undefined; @@ -61,6 +72,7 @@ export class JourneyFtrHarness { // journey can be run to collect EBT/APM metrics or just as a functional test // TEST_PERFORMANCE_PHASE is defined via scripts/run_perfomance.js run only private readonly isPerformanceRun = process.env.TEST_PERFORMANCE_PHASE || false; + private readonly isWarmupPhase = process.env.TEST_PERFORMANCE_PHASE === 'WARMUP'; // Update the Telemetry and APM global labels to link traces with journey private async updateTelemetryAndAPMLabels(labels: { [k: string]: string }) { @@ -158,16 +170,54 @@ export class JourneyFtrHarness { await this.interceptBrowserRequests(this.page); } + private async runSynthtrace() { + const config = this.journeyConfig.getSynthtraceConfig(); + if (config) { + const client = await getSynthtraceClient(config.type, { + log: this.log, + es: this.es, + auth: this.auth, + kbnUrl: this.kbnUrl, + }); + const generator = config.generator(config.options); + await client.index(generator); + } + } + + /** + * onSetup is part of high level 'before' hook and does the following sequentially: + * 1. Start browser + * 2. Load test data (opt-in) + * 3. Run BeforeSteps (opt-in) + * 4. Setup APM + */ private async onSetup() { // We start browser and init page in the first place await this.setupBrowserAndPage(); - // We allow opt-in beforeSteps hook to manage Kibana/ES state + + // We allow opt-in beforeSteps hook to manage Kibana/ES after start, install integrations, etc. await this.journeyConfig.getBeforeStepsFn(this.getCtx()); - // Loading test data + + /** + * Loading test data, optionally but following the order: + * 1. Synthtrace client + * 2. ES archives + * 3. Kbn archives (Saved objects) + */ + + // To insure we ingest data with synthtrace only once during performance run + if (!this.isPerformanceRun || this.isWarmupPhase) { + await this.runSynthtrace(); + } + await Promise.all([ asyncForEach(this.journeyConfig.getEsArchives(), async (esArchive) => { if (this.isPerformanceRun) { - // we start Elasticsearch only once and keep ES data persisitent. + // + /** + * During performance run we ingest data to ES before WARMUP phase, and avoid re-indexing + * before TEST phase by insuring index already exists + */ await this.esArchiver.loadIfNeeded(esArchive); } else { await this.esArchiver.load(esArchive); @@ -242,7 +292,9 @@ export class JourneyFtrHarness { await this.teardownApm(); await Promise.all([ asyncForEach(this.journeyConfig.getEsArchives(), async (esArchive) => { - // Keep ES data when journey is run twice (avoid unload after "Warmup" phase) + /** + * Keep ES data after WARMUP phase to avoid re-indexing + */ if (!this.isPerformanceRun) { await this.esArchiver.unload(esArchive); } diff --git a/packages/kbn-journeys/kibana.jsonc b/packages/kbn-journeys/kibana.jsonc index b90e3b548d1ef..227c4b20cf080 100644 --- a/packages/kbn-journeys/kibana.jsonc +++ b/packages/kbn-journeys/kibana.jsonc @@ -1,5 +1,5 @@ { - "type": "shared-common", + "type": "test-helper", "id": "@kbn/journeys", "owner": ["@elastic/kibana-operations", "@elastic/appex-qa"], "devOnly": true diff --git a/packages/kbn-journeys/services/synthtrace.ts b/packages/kbn-journeys/services/synthtrace.ts new file mode 100644 index 0000000000000..ffb4f06f20007 --- /dev/null +++ b/packages/kbn-journeys/services/synthtrace.ts @@ -0,0 +1,123 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +import { + ApmSynthtraceEsClient, + ApmSynthtraceKibanaClient, + InfraSynthtraceEsClient, + InfraSynthtraceKibanaClient, +} from '@kbn/apm-synthtrace'; +import { ToolingLog } from '@kbn/tooling-log'; +import Url from 'url'; +import { Logger } from '@kbn/apm-synthtrace/src/lib/utils/create_logger'; +import { Auth, Es } from '.'; +import { KibanaUrl } from './kibana_url'; + +export interface SynthtraceClientOptions { + kbnUrl: KibanaUrl; + auth: Auth; + es: Es; + log: ToolingLog; +} +export type SynthtraceClient = InfraSynthtraceEsClient | ApmSynthtraceEsClient; +export type SynthtraceClientType = 'infra' | 'apm'; + +export async function getSynthtraceClient( + type: SynthtraceClientType, + options: SynthtraceClientOptions +): Promise { + if (type === 'infra') { + return initInfraSynthtraceClient(options); + } else { + return initApmSynthtraceClient(options); + } +} + +// Adapting ToolingLog instance to Logger interface +class LoggerAdapter implements Logger { + private log: ToolingLog; + private joiner = ', '; + + constructor(log: ToolingLog) { + this.log = log; + } + + debug(...args: any[]): void { + this.log.debug(args.join(this.joiner)); + } + + info(...args: any[]): void { + this.log.info(args.join(this.joiner)); + } + + error(arg: string | Error): void { + this.log.error(arg); + } + + perf(name: string, cb: () => T): T { + const startTime = Date.now(); + const result = cb(); + const duration = Date.now() - startTime; + const durationInSeconds = duration / 1000; + const formattedTime = durationInSeconds.toFixed(3) + 's'; + this.log.info(`${name} took ${formattedTime}.`); + return result; + } +} + +async function initInfraSynthtraceClient(options: SynthtraceClientOptions) { + const { log, es, auth, kbnUrl } = options; + const logger: Logger = new LoggerAdapter(log); + + const synthKbnClient = new InfraSynthtraceKibanaClient({ + logger, + target: kbnUrl.get(), + username: auth.getUsername(), + password: auth.getPassword(), + }); + const pkgVersion = await synthKbnClient.fetchLatestSystemPackageVersion(); + await synthKbnClient.installSystemPackage(pkgVersion); + + const synthEsClient = new InfraSynthtraceEsClient({ + logger, + client: es, + refreshAfterIndex: true, + }); + + return synthEsClient; +} + +async function initApmSynthtraceClient(options: SynthtraceClientOptions) { + const { log, es, auth, kbnUrl } = options; + const logger: Logger = new LoggerAdapter(log); + const kibanaUrl = new URL(kbnUrl.get()); + const kibanaUrlWithAuth = Url.format({ + protocol: kibanaUrl.protocol, + hostname: kibanaUrl.hostname, + port: kibanaUrl.port, + auth: `${auth.getUsername()}:${auth.getPassword()}`, + }); + + const synthKbnClient = new ApmSynthtraceKibanaClient({ + logger, + target: kibanaUrlWithAuth, + }); + const packageVersion = await synthKbnClient.fetchLatestApmPackageVersion(); + await synthKbnClient.installApmPackage(packageVersion); + + const synthEsClient = new ApmSynthtraceEsClient({ + client: es, + logger, + refreshAfterIndex: true, + version: packageVersion, + }); + + synthEsClient.pipeline(synthEsClient.getDefaultPipeline(false)); + + return synthEsClient; +} diff --git a/packages/kbn-journeys/tsconfig.json b/packages/kbn-journeys/tsconfig.json index 7917081cb1847..93165418b575a 100644 --- a/packages/kbn-journeys/tsconfig.json +++ b/packages/kbn-journeys/tsconfig.json @@ -19,6 +19,8 @@ "@kbn/std", "@kbn/test-subj-selector", "@kbn/core-http-common", + "@kbn/apm-synthtrace-client", + "@kbn/apm-synthtrace", ], "exclude": [ "target/**/*", diff --git a/packages/kbn-performance-testing-dataset-extractor/kibana.jsonc b/packages/kbn-performance-testing-dataset-extractor/kibana.jsonc index 1363aaa66d61f..e60de9931231e 100644 --- a/packages/kbn-performance-testing-dataset-extractor/kibana.jsonc +++ b/packages/kbn-performance-testing-dataset-extractor/kibana.jsonc @@ -1,5 +1,5 @@ { - "type": "shared-common", + "type": "test-helper", "id": "@kbn/performance-testing-dataset-extractor", "devOnly": true, "owner": "@elastic/kibana-performance-testing" diff --git a/x-pack/performance/journeys_e2e/apm_service_inventory.ts b/x-pack/performance/journeys_e2e/apm_service_inventory.ts index f6f2f3731a65b..2c4b3803f5c32 100644 --- a/x-pack/performance/journeys_e2e/apm_service_inventory.ts +++ b/x-pack/performance/journeys_e2e/apm_service_inventory.ts @@ -7,36 +7,19 @@ import { Journey } from '@kbn/journeys'; import { subj } from '@kbn/test-subj-selector'; -import { SynthtraceClient } from '../services/synthtrace'; -import { generateData } from '../synthtrace_data/apm_data'; +import { generateApmData } from '../synthtrace_data/apm_data'; export const journey = new Journey({ - beforeSteps: async ({ kbnUrl, log, auth, es }) => { - // Install APM Package - const synthClient = new SynthtraceClient({ - kbnBaseUrl: kbnUrl.get(), - logger: log, - username: auth.getUsername(), - password: auth.getPassword(), - esClient: es, - }); - - await synthClient.installApmPackage(); - // Setup Synthtrace Client - await synthClient.initialiseEsClient(); - // Generate data using Synthtrace - const start = Date.now() - 1000 * 60 * 15; - const end = Date.now() + 1000 * 60 * 15; - await synthClient.index( - generateData({ - from: new Date(start).getTime(), - to: new Date(end).getTime(), - }) - ); + synthtrace: { + type: 'apm', + generator: generateApmData, + options: { + from: new Date(Date.now() - 1000 * 60 * 15), + to: new Date(Date.now() + 1000 * 60 * 15), + }, }, + ftrConfigPath: 'x-pack/performance/configs/apm_config.ts', - // FLAKY: https://github.com/elastic/kibana/issues/162813 - skipped: true, }) .step('Navigate to Service Inventory Page', async ({ page, kbnUrl }) => { await page.goto(kbnUrl.get(`app/apm/services`)); diff --git a/x-pack/performance/journeys_e2e/infra_hosts_view.ts b/x-pack/performance/journeys_e2e/infra_hosts_view.ts index 893eb835a796d..d7f2beb661ce3 100644 --- a/x-pack/performance/journeys_e2e/infra_hosts_view.ts +++ b/x-pack/performance/journeys_e2e/infra_hosts_view.ts @@ -6,42 +6,18 @@ */ import { Journey } from '@kbn/journeys'; -import { - createLogger, - InfraSynthtraceEsClient, - LogLevel, - InfraSynthtraceKibanaClient, -} from '@kbn/apm-synthtrace'; -import { infra, timerange } from '@kbn/apm-synthtrace-client'; import { subj } from '@kbn/test-subj-selector'; +import { generateHostsData } from '../synthtrace_data/hosts_data'; export const journey = new Journey({ - beforeSteps: async ({ kbnUrl, auth, es }) => { - const logger = createLogger(LogLevel.debug); - const synthKibanaClient = new InfraSynthtraceKibanaClient({ - logger, - target: kbnUrl.get(), - username: auth.getUsername(), - password: auth.getPassword(), - }); - - const pkgVersion = await synthKibanaClient.fetchLatestSystemPackageVersion(); - await synthKibanaClient.installSystemPackage(pkgVersion); - - const synthEsClient = new InfraSynthtraceEsClient({ - logger, - client: es, - refreshAfterIndex: true, - }); - - const start = Date.now() - 1000 * 60 * 10; - await synthEsClient.index( - generateHostsData({ - from: new Date(start).toISOString(), - to: new Date().toISOString(), - count: 1000, - }) - ); + synthtrace: { + type: 'infra', + generator: generateHostsData, + options: { + from: new Date(Date.now() - 1000 * 60 * 10), + to: new Date(), + count: 1000, + }, }, }) .step('Navigate to Hosts view and load 500 hosts', async ({ page, kbnUrl, kibanaPage }) => { @@ -63,33 +39,3 @@ export const journey = new Journey({ // wait for metric charts on the asset details view to be loaded await kibanaPage.waitForCharts({ count: 4, timeout: 60000 }); }); - -export function generateHostsData({ - from, - to, - count = 1, -}: { - from: string; - to: string; - count: number; -}) { - const range = timerange(from, to); - - const hosts = Array(count) - .fill(0) - .map((_, idx) => infra.host(`my-host-${idx}`)); - - return range - .interval('30s') - .rate(1) - .generator((timestamp, index) => - hosts.flatMap((host) => [ - host.cpu().timestamp(timestamp), - host.memory().timestamp(timestamp), - host.network().timestamp(timestamp), - host.load().timestamp(timestamp), - host.filesystem().timestamp(timestamp), - host.diskio().timestamp(timestamp), - ]) - ); -} diff --git a/x-pack/performance/services/synthtrace/index.ts b/x-pack/performance/services/synthtrace/index.ts deleted file mode 100644 index fc7ac5c306b62..0000000000000 --- a/x-pack/performance/services/synthtrace/index.ts +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License - * 2.0; you may not use this file except in compliance with the Elastic License - * 2.0. - */ - -import { ApmSynthtraceEsClient, ApmSynthtraceKibanaClient } from '@kbn/apm-synthtrace'; -import Url from 'url'; -import { Readable } from 'stream'; -import { ApmFields, SynthtraceGenerator } from '@kbn/apm-synthtrace-client'; - -export interface SynthtraceClientParams { - kbnBaseUrl: string; - logger: any; - username: string; - password: string; - esClient: any; -} - -export class SynthtraceClient { - private synthtraceEsClient: ApmSynthtraceEsClient | undefined; - private packageVersion: string = ''; - private readonly kibanaUrlWithAuth: string; - - constructor(private readonly baseParams: SynthtraceClientParams) { - const kibanaUrl = new URL(this.baseParams.kbnBaseUrl); - this.kibanaUrlWithAuth = Url.format({ - protocol: kibanaUrl.protocol, - hostname: kibanaUrl.hostname, - port: kibanaUrl.port, - auth: `${this.baseParams.username}:${this.baseParams.password}`, - }); - } - - async installApmPackage() { - const kibanaClient = new ApmSynthtraceKibanaClient({ - logger: this.baseParams.logger, - target: this.kibanaUrlWithAuth, - }); - this.packageVersion = await kibanaClient.fetchLatestApmPackageVersion(); - - await kibanaClient.installApmPackage(this.packageVersion); - } - - async initialiseEsClient() { - this.synthtraceEsClient = new ApmSynthtraceEsClient({ - client: this.baseParams.esClient, - logger: this.baseParams.logger, - refreshAfterIndex: true, - version: this.packageVersion, - }); - - this.synthtraceEsClient.pipeline(this.synthtraceEsClient.getDefaultPipeline(false)); - } - - async index(events: SynthtraceGenerator) { - if (this.synthtraceEsClient) { - await this.synthtraceEsClient.index( - Readable.from(Array.from(events).flatMap((event) => event.serialize())) - ); - } else { - throw new Error('ES Client not initialised'); - } - } -} diff --git a/x-pack/performance/synthtrace_data/apm_data.ts b/x-pack/performance/synthtrace_data/apm_data.ts index 4a7ab835d37cd..4adf560a94044 100644 --- a/x-pack/performance/synthtrace_data/apm_data.ts +++ b/x-pack/performance/synthtrace_data/apm_data.ts @@ -5,9 +5,10 @@ * 2.0. */ import { apm, httpExitSpan, timerange } from '@kbn/apm-synthtrace-client'; +import { Readable } from 'stream'; -export function generateData({ from, to }: { from: number; to: number }) { - const range = timerange(from, to); +export function generateApmData({ from, to }: { from: Date; to: Date }) { + const range = timerange(from.toISOString(), to.toISOString()); const transactionName = '240rpm/75% 1000ms'; const synthRum = apm @@ -20,7 +21,7 @@ export function generateData({ from, to }: { from: number; to: number }) { .service({ name: 'synth-go', environment: 'production', agentName: 'go' }) .instance('my-instance'); - return range.interval('1m').generator((timestamp) => { + const data = range.interval('1m').generator((timestamp) => { return synthRum .transaction({ transactionName }) .duration(400) @@ -74,4 +75,6 @@ export function generateData({ from, to }: { from: number; to: number }) { ) ); }); + + return Readable.from(Array.from(data).flatMap((event) => event.serialize())); } diff --git a/x-pack/performance/synthtrace_data/hosts_data.ts b/x-pack/performance/synthtrace_data/hosts_data.ts new file mode 100644 index 0000000000000..3d9de1a0dbebc --- /dev/null +++ b/x-pack/performance/synthtrace_data/hosts_data.ts @@ -0,0 +1,37 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0; you may not use this file except in compliance with the Elastic License + * 2.0. + */ +import { infra, timerange } from '@kbn/apm-synthtrace-client'; + +export function generateHostsData({ + from, + to, + count = 1, +}: { + from: Date; + to: Date; + count?: number; +}) { + const range = timerange(from.toISOString(), to.toISOString()); + + const hosts = Array(count) + .fill(0) + .map((_, idx) => infra.host(`my-host-${idx}`)); + + return range + .interval('30s') + .rate(1) + .generator((timestamp, index) => + hosts.flatMap((host) => [ + host.cpu().timestamp(timestamp), + host.memory().timestamp(timestamp), + host.network().timestamp(timestamp), + host.load().timestamp(timestamp), + host.filesystem().timestamp(timestamp), + host.diskio().timestamp(timestamp), + ]) + ); +} diff --git a/x-pack/performance/tsconfig.json b/x-pack/performance/tsconfig.json index 8dcd1caca873f..c03760e8db434 100644 --- a/x-pack/performance/tsconfig.json +++ b/x-pack/performance/tsconfig.json @@ -15,7 +15,6 @@ "@kbn/test", "@kbn/expect", "@kbn/dev-utils", - "@kbn/apm-synthtrace", "@kbn/apm-synthtrace-client", ] }