[APM] Mobile most launches

packages/kbn-apm-synthtrace-client/src/lib/apm/apm_fields.ts

@@ -38,6 +38,7 @@ export type ApmUserAgentFields = Partial<{
 export interface ApmException {
   message: string;
 }
+
 export interface Observer {
   type: string;
   version: string;
@@ -94,6 +95,7 @@ export type ApmFields = Fields<{
     'error.type': string;
     'event.ingested': number;
     'event.name': string;
+    'event.kind': string;
     'event.outcome': string;
     'event.outcome_numeric':
       | number
@@ -121,6 +123,7 @@ export type ApmFields = Fields<{
     'kubernetes.pod.uid': string;
     'labels.name': string;
     'labels.telemetry_auto_version': string;
+    'labels.lifecycle_state': string;
     'metricset.name': string;
     'network.carrier.icc': string;
     'network.carrier.mcc': string;

packages/kbn-apm-synthtrace-client/src/lib/apm/event.ts

@@ -0,0 +1,36 @@
+/*
+ * 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 { ApmFields } from './apm_fields';
+import { Serializable } from '../serializable';
+
+export class Event extends Serializable<ApmFields> {
+  constructor(fields: ApmFields) {
+    super({
+      ...fields,
+      'event.kind': 'event',
+
+      // Real log events don't have the "processor.event" attribute. See: https://github.com/elastic/apm-server/pull/11494
+      // This is a hack needed for the tests in "mobile/mobile_location_stats.spec.ts" to pass since the "SynthtraceEsClient.index" function
+      // inside "packages/kbn-apm-synthtrace/src/lib/shared/base_client.ts" requires this "processor.event" attr to be available,
+      // otherwise it'd throw this error: "Could not determine operation: _index and _action not defined in document".
+      'processor.event': 'error',
+    });
+  }
+
+  lifecycle(state: string): this {
+    this.fields['labels.lifecycle_state'] = state;
+    return this;
+  }
+
+  override timestamp(timestamp: number) {
+    const ret = super.timestamp(timestamp);
+    this.fields['timestamp.us'] = timestamp * 1000;
+    return ret;
+  }
+}

packages/kbn-apm-synthtrace-client/src/lib/apm/mobile_device.ts

@@ -9,7 +9,8 @@
 import { Entity } from '../entity';
 import { Span } from './span';
 import { Transaction } from './transaction';
-import { ApmFields, SpanParams, GeoLocation, ApmApplicationMetricFields } from './apm_fields';
+import { Event } from './event';
+import { ApmApplicationMetricFields, ApmFields, GeoLocation, SpanParams } from './apm_fields';
 import { generateLongId } from '../utils/generate_id';
 import { Metricset } from './metricset';
 import { ApmError } from './apm_error';
@@ -143,6 +144,10 @@ export class MobileDevice extends Entity<ApmFields> {
     return this;
   }
 
+  event(): Event {
+    return new Event({ ...this.fields });
+  }
+
   transaction(
     ...options:
       | [{ transactionName: string; frameworkName?: string; frameworkVersion?: string }]

packages/kbn-apm-synthtrace-client/src/lib/apm/transaction.ts

@@ -7,6 +7,7 @@
  */
 
 import { ApmError } from './apm_error';
+import { Event } from './event';
 import { BaseSpan } from './base_span';
 import { generateShortId } from '../utils/generate_id';
 import { ApmFields } from './apm_fields';
@@ -15,6 +16,7 @@ import { getBreakdownMetrics } from './processors/get_breakdown_metrics';
 export class Transaction extends BaseSpan {
   private _sampled: boolean = true;
   private readonly _errors: ApmError[] = [];
+  private readonly _events: Event[] = [];
 
   constructor(fields: ApmFields) {
     super({
@@ -35,6 +37,27 @@ export class Transaction extends BaseSpan {
       error.fields['transaction.sampled'] = this.fields['transaction.sampled'];
     });
 
+    this._events.forEach((event) => {
+      event.fields['trace.id'] = this.fields['trace.id'];
+      event.fields['transaction.id'] = this.fields['transaction.id'];
+      event.fields['transaction.type'] = this.fields['transaction.type'];
+      event.fields['transaction.sampled'] = this.fields['transaction.sampled'];
+    });
+
+    return this;
+  }
+
+  events(...events: Event[]) {
+    events.forEach((event) => {
+      event.fields['trace.id'] = this.fields['trace.id'];
+      event.fields['transaction.id'] = this.fields['transaction.id'];
+      event.fields['transaction.name'] = this.fields['transaction.name'];
+      event.fields['transaction.type'] = this.fields['transaction.type'];
+      event.fields['transaction.sampled'] = this.fields['transaction.sampled'];
+    });
+
+    this._events.push(...events);
+
     return this;
   }
 
@@ -62,13 +85,17 @@ export class Transaction extends BaseSpan {
     this._errors.forEach((error) => {
       error.fields['transaction.sampled'] = sampled;
     });
+    this._events.forEach((event) => {
+      event.fields['transaction.sampled'] = sampled;
+    });
     return this;
   }
 
   serialize() {
     const [transaction, ...spans] = super.serialize();
 
     const errors = this._errors.flatMap((error) => error.serialize());
+    const logEvents = this._events.flatMap((event) => event.serialize());
 
     const directChildren = this.getChildren().map((child) => child.fields);
 
@@ -80,6 +107,6 @@ export class Transaction extends BaseSpan {
       events.push(...spans);
     }
 
-    return events.concat(errors).concat(breakdownMetrics);
+    return events.concat(errors).concat(breakdownMetrics).concat(logEvents);
   }
 }

x-pack/plugins/apm/public/components/app/mobile/service_overview/stats/location_stats.tsx

@@ -163,17 +163,18 @@ export function MobileLocationStats({
       trendShape: MetricTrendShape.Area,
     },
     {
-      color: euiTheme.eui.euiColorDisabled,
+      color: euiTheme.eui.euiColorLightestShade,
       title: i18n.translate('xpack.apm.mobile.location.metrics.launches', {
         defaultMessage: 'Most launches',
       }),
-      subtitle: i18n.translate('xpack.apm.mobile.coming.soon', {
-        defaultMessage: 'Coming Soon',
+      extra: getComparisonValueFormatter({
+        currentPeriodValue: currentPeriod?.mostLaunches.value,
+        previousPeriodValue: previousPeriod?.mostLaunches.value,
       }),
       icon: getIcon('launch'),
-      value: NOT_AVAILABLE_LABEL,
+      value: currentPeriod?.mostLaunches.location ?? NOT_AVAILABLE_LABEL,
       valueFormatter: (value) => `${value}`,
-      trend: [],
+      trend: currentPeriod?.mostLaunches.timeseries,
       trendShape: MetricTrendShape.Area,
     },
   ];

x-pack/plugins/apm/server/lib/helpers/create_es_client/create_apm_event_client/get_request_base.ts

@@ -10,7 +10,6 @@ import type { APMIndices } from '@kbn/apm-data-access-plugin/server';
 import { ProcessorEvent } from '@kbn/observability-plugin/common';
 import { uniq } from 'lodash';
 import { ApmDataSource } from '../../../../../common/data_source';
-import {} from '../../../../../common/document_type';
 import { PROCESSOR_EVENT } from '../../../../../common/es_fields/apm';
 import {
   getConfigForDocumentType,

x-pack/plugins/apm/server/lib/helpers/create_es_client/create_apm_event_client/index.ts

@@ -11,11 +11,12 @@ import type {
   FieldCapsResponse,
   MsearchMultisearchBody,
   MsearchMultisearchHeader,
-  TermsEnumResponse,
   TermsEnumRequest,
+  TermsEnumResponse,
 } from '@elastic/elasticsearch/lib/api/types';
 import { ElasticsearchClient, KibanaRequest } from '@kbn/core/server';
 import type { ESSearchRequest, InferSearchResponseOf } from '@kbn/es-types';
+import { ESFilter } from '@kbn/es-types';
 import { ProcessorEvent } from '@kbn/observability-plugin/common';
 import { unwrapEsResponse } from '@kbn/observability-plugin/server';
 import { compact, omit } from 'lodash';
@@ -26,6 +27,7 @@ import { APMError } from '../../../../../typings/es_schemas/ui/apm_error';
 import { Metric } from '../../../../../typings/es_schemas/ui/metric';
 import { Span } from '../../../../../typings/es_schemas/ui/span';
 import { Transaction } from '../../../../../typings/es_schemas/ui/transaction';
+import { Event } from '../../../../../typings/es_schemas/ui/event';
 import { withApmSpan } from '../../../../utils/with_apm_span';
 import {
   callAsyncWithDebug,
@@ -46,6 +48,13 @@ export type APMEventESSearchRequest = Omit<ESSearchRequest, 'index'> & {
   };
 };
 
+export type APMLogEventESSearchRequest = Omit<ESSearchRequest, 'index'> & {
+  body: {
+    size: number;
+    track_total_hits: boolean | number;
+  };
+};
+
 type APMEventWrapper<T> = Omit<T, 'index'> & {
   apm: { events: ProcessorEvent[] };
 };
@@ -63,6 +72,9 @@ type TypeOfProcessorEvent<T extends ProcessorEvent> = {
   metric: Metric;
 }[T];
 
+type TypedLogEventSearchResponse<TParams extends APMLogEventESSearchRequest> =
+  InferSearchResponseOf<Event, TParams>;
+
 type TypedSearchResponse<TParams extends APMEventESSearchRequest> =
   InferSearchResponseOf<
     TypeOfProcessorEvent<
@@ -196,6 +208,50 @@ export class APMEventClient {
     });
   }
 
+  async logEventSearch<TParams extends APMLogEventESSearchRequest>(
+    operationName: string,
+    params: TParams
+  ): Promise<TypedLogEventSearchResponse<TParams>> {
+    // Reusing indices configured for errors since both events and errors are stored as logs.
+    const index = processorEventsToIndex([ProcessorEvent.error], this.indices);
+
+    const filters: ESFilter[] = [
+      {
+        terms: {
+          ['event.kind']: ['event'],
+        },
+      },
+    ];
+
+    const searchParams = {
+      ...omit(params, 'body'),
+      index,
+      body: {
+        ...params.body,
+        query: {
+          bool: {
+            filter: filters,
+            must: compact([params.body.query]),
+          },
+        },
+      },
+      ...(this.includeFrozen ? { ignore_throttled: false } : {}),
+      ignore_unavailable: true,
+      preference: 'any',
+      expand_wildcards: ['open' as const, 'hidden' as const],
+    };
+
+    return this.callAsyncWithDebug({
+      cb: (opts) =>
+        this.esClient.search(searchParams, opts) as unknown as Promise<{
+          body: TypedLogEventSearchResponse<TParams>;
+        }>,
+      operationName,
+      params: searchParams,
+      requestType: 'search',
+    });
+  }
+
   async msearch<TParams extends APMEventESSearchRequest>(
     operationName: string,
     ...allParams: TParams[]

x-pack/plugins/apm/server/routes/mobile/get_mobile_launches_by_location.ts

@@ -0,0 +1,111 @@
+/*
+ * 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 {
+  kqlQuery,
+  rangeQuery,
+  termQuery,
+} from '@kbn/observability-plugin/server';
+import { SERVICE_NAME } from '../../../common/es_fields/apm';
+import { APMEventClient } from '../../lib/helpers/create_es_client/create_apm_event_client';
+import { getOffsetInMs } from '../../../common/utils/get_offset_in_ms';
+import { getBucketSize } from '../../../common/utils/get_bucket_size';
+import { environmentQuery } from '../../../common/utils/environment_query';
+
+interface Props {
+  kuery: string;
+  apmEventClient: APMEventClient;
+  serviceName: string;
+  environment: string;
+  start: number;
+  end: number;
+  locationField?: string;
+  offset?: string;
+}
+
+export async function getLaunchesByLocation({
+  kuery,
+  apmEventClient,
+  serviceName,
+  environment,
+  start,
+  end,
+  locationField,
+  offset,
+}: Props) {
+  const { startWithOffset, endWithOffset } = getOffsetInMs({
+    start,
+    end,
+    offset,
+  });
+
+  const { intervalString } = getBucketSize({
+    start: startWithOffset,
+    end: endWithOffset,
+    minBucketSize: 60,
+  });
+
+  const aggs = {
+    launches: {
+      filter: {
+        terms: { ['labels.lifecycle_state']: ['created', 'active'] },
+      },
+      aggs: {
+        byLocation: {
+          terms: {
+            field: locationField,
+          },
+        },
+      },
+    },
+  };
+
+  const response = await apmEventClient.logEventSearch(
+    'get_mobile_location_launches',
+    {
+      body: {
+        track_total_hits: false,
+        size: 0,
+        query: {
+          bool: {
+            filter: [
+              ...termQuery(SERVICE_NAME, serviceName),
+              ...rangeQuery(startWithOffset, endWithOffset),
+              ...environmentQuery(environment),
+              ...kqlQuery(kuery),
+            ],
+          },
+        },
+        aggs: {
+          timeseries: {
+            date_histogram: {
+              field: '@timestamp',
+              fixed_interval: intervalString,
+              min_doc_count: 0,
+            },
+            aggs,
+          },
+          ...aggs,
+        },
+      },
+    }
+  );
+
+  return {
+    location: response.aggregations?.launches?.byLocation?.buckets[0]
+      ?.key as string,
+    value:
+      response.aggregations?.launches?.byLocation?.buckets[0]?.doc_count ?? 0,
+    timeseries:
+      response.aggregations?.timeseries?.buckets.map((bucket) => ({
+        x: bucket.key,
+        y:
+          response.aggregations?.launches?.byLocation?.buckets[0]?.doc_count ??
+          0,
+      })) ?? [],
+  };
+}