Adding endpoint to upload android map files

x-pack/plugins/apm/server/routes/fleet/source_maps.ts

@@ -19,12 +19,18 @@ import { getPackagePolicyWithSourceMap } from './get_package_policy_decorators';
 
 const doUnzip = promisify(unzip);
 
-interface ApmSourceMapArtifactBody {
+interface ApmMapArtifactBody {
   serviceName: string;
   serviceVersion: string;
   bundleFilepath: string;
+  sourceMap: string;
+}
+
+interface ApmSourceMapArtifactBody
+  extends Omit<ApmMapArtifactBody, 'sourceMap'> {
   sourceMap: SourceMap;
 }
+
 export type ArtifactSourceMap = Omit<Artifact, 'body'> & {
   body: ApmSourceMapArtifactBody;
 };
@@ -104,6 +110,23 @@ export async function createFleetSourceMapArtifact({
   });
 }
 
+export async function createFleetAndroidMapArtifact({
+  apmArtifactBody,
+  fleetPluginStart,
+}: {
+  apmArtifactBody: ApmMapArtifactBody;
+  fleetPluginStart: FleetPluginStart;
+}) {
+  const apmArtifactClient = getApmArtifactClient(fleetPluginStart);
+  const identifier = `${apmArtifactBody.serviceName}-${apmArtifactBody.serviceVersion}-android`;
+
+  return apmArtifactClient.createArtifact({
+    type: 'sourcemap',
+    identifier,
+    content: JSON.stringify(apmArtifactBody),
+  });
+}
+
 export async function deleteFleetSourcemapArtifact({
   id,
   fleetPluginStart,

x-pack/plugins/apm/server/routes/source_maps/bulk_create_apm_source_maps.ts

@@ -10,7 +10,7 @@ import { Artifact } from '@kbn/fleet-plugin/server';
 import { getUnzippedArtifactBody } from '../fleet/source_maps';
 import { APM_SOURCE_MAP_INDEX } from '../settings/apm_indices/get_apm_indices';
 import { ApmSourceMap } from './create_apm_source_map_index_template';
-import { getEncodedContent, getSourceMapId } from './sourcemap_utils';
+import { getEncodedSourceMapContent, getSourceMapId } from './sourcemap_utils';
 
 export async function bulkCreateApmSourceMaps({
   artifacts,
@@ -24,7 +24,7 @@ export async function bulkCreateApmSourceMaps({
       const { serviceName, serviceVersion, bundleFilepath, sourceMap } =
         await getUnzippedArtifactBody(artifact.body);
 
-      const { contentEncoded, contentHash } = await getEncodedContent(
+      const { contentEncoded, contentHash } = await getEncodedSourceMapContent(
         sourceMap
       );
 

x-pack/plugins/apm/server/routes/source_maps/create_apm_source_map.ts

@@ -10,7 +10,11 @@ import { Logger } from '@kbn/core/server';
 import { APM_SOURCE_MAP_INDEX } from '../settings/apm_indices/get_apm_indices';
 import { ApmSourceMap } from './create_apm_source_map_index_template';
 import { SourceMap } from './route';
-import { getEncodedContent, getSourceMapId } from './sourcemap_utils';
+import {
+  getEncodedSourceMapContent,
+  getEncodedContent,
+  getSourceMapId,
+} from './sourcemap_utils';
 
 export async function createApmSourceMap({
   internalESClient,
@@ -31,9 +35,75 @@ export async function createApmSourceMap({
   serviceName: string;
   serviceVersion: string;
 }) {
-  const { contentEncoded, contentHash } = await getEncodedContent(
+  const { contentEncoded, contentHash } = await getEncodedSourceMapContent(
     sourceMapContent
   );
+  return await doCreateApmMap({
+    internalESClient,
+    logger,
+    fleetId,
+    created,
+    bundleFilepath,
+    serviceName,
+    serviceVersion,
+    contentEncoded,
+    contentHash,
+  });
+}
+
+export async function createApmAndroidMap({
+  internalESClient,
+  logger,
+  fleetId,
+  created,
+  mapContent,
+  bundleFilepath,
+  serviceName,
+  serviceVersion,
+}: {
+  internalESClient: ElasticsearchClient;
+  logger: Logger;
+  fleetId: string;
+  created: string;
+  mapContent: string;
+  bundleFilepath: string;
+  serviceName: string;
+  serviceVersion: string;
+}) {
+  const { contentEncoded, contentHash } = await getEncodedContent(mapContent);
+  return await doCreateApmMap({
+    internalESClient,
+    logger,
+    fleetId,
+    created,
+    bundleFilepath,
+    serviceName,
+    serviceVersion,
+    contentEncoded,
+    contentHash,
+  });
+}
+async function doCreateApmMap({
+  internalESClient,
+  logger,
+  fleetId,
+  created,
+  bundleFilepath,
+  serviceName,
+  serviceVersion,
+  contentEncoded,
+  contentHash,
+}: {
+  internalESClient: ElasticsearchClient;
+  logger: Logger;
+  fleetId: string;
+  created: string;
+  bundleFilepath: string;
+  serviceName: string;
+  serviceVersion: string;
+  contentEncoded: string;
+  contentHash: string;
+}) {
   const doc: ApmSourceMap = {
     fleet_id: fleetId,
     created,

x-pack/plugins/apm/server/routes/source_maps/route.ts

@@ -9,19 +9,24 @@ import { SavedObjectsClientContract } from '@kbn/core/server';
 import { Artifact } from '@kbn/fleet-plugin/server';
 import { jsonRt, toNumberRt } from '@kbn/io-ts-utils';
 import * as t from 'io-ts';
+import { either } from 'fp-ts/lib/Either';
 import { ApmFeatureFlags } from '../../../common/apm_feature_flags';
 import { getInternalSavedObjectsClient } from '../../lib/helpers/get_internal_saved_objects_client';
 import { stringFromBufferRt } from '../../utils/string_from_buffer_rt';
 import { createApmServerRoute } from '../apm_routes/create_apm_server_route';
 import {
   createFleetSourceMapArtifact,
+  createFleetAndroidMapArtifact,
   deleteFleetSourcemapArtifact,
   getCleanedBundleFilePath,
   listSourceMapArtifacts,
   ListSourceMapArtifactsResponse,
   updateSourceMapsOnFleetPolicies,
 } from '../fleet/source_maps';
-import { createApmSourceMap } from './create_apm_source_map';
+import {
+  createApmSourceMap,
+  createApmAndroidMap,
+} from './create_apm_source_map';
 import { deleteApmSourceMap } from './delete_apm_sourcemap';
 import { runFleetSourcemapArtifactsMigration } from './schedule_source_map_migration';
 
@@ -41,6 +46,24 @@ export const sourceMapRt = t.intersection([
 
 export type SourceMap = t.TypeOf<typeof sourceMapRt>;
 
+const androidMapValidation = new t.Type<string, string, unknown>(
+  'ANDROID_MAP_VALIDATION',
+  t.string.is,
+  (input, context): t.Validation<string> =>
+    either.chain(
+      t.string.validate(input, context),
+      (str): t.Validation<string> => {
+        const firstLine = str.split('\n', 1)[0];
+        if (firstLine.trim() === '# compiler: R8') {
+          return t.success(str);
+        } else {
+          return t.failure(input, context);
+        }
+      }
+    ),
+  (a): string => a
+);
+
 function throwNotImplementedIfSourceMapNotAvailable(
   featureFlags: ApmFeatureFlags
 ): void {
@@ -169,6 +192,85 @@ const uploadSourceMapRoute = createApmServerRoute({
   },
 });
 
+const uploadAndroidMapRoute = createApmServerRoute({
+  endpoint: 'POST /api/apm/androidmaps 2023-10-31',
+  options: {
+    tags: ['access:apm', 'access:apm_write'],
+    body: { accepts: ['multipart/form-data'], maxBytes: 30 * 1024 * 1024 },
+  },
+  params: t.type({
+    body: t.type({
+      service_name: t.string,
+      service_version: t.string,
+      map_file: t
+        .union([t.string, stringFromBufferRt])
+        .pipe(androidMapValidation),
+    }),
+  }),
+  handler: async ({
+    params,
+    plugins,
+    core,
+    logger,
+    featureFlags,
+  }): Promise<Artifact | undefined> => {
+    throwNotImplementedIfSourceMapNotAvailable(featureFlags);
+
+    const {
+      service_name: serviceName,
+      service_version: serviceVersion,
+      map_file: sourceMapContent,
+    } = params.body;
+    const bundleFilePath = 'android';
+    const fleetPluginStart = await plugins.fleet?.start();
+    const coreStart = await core.start();
+    const internalESClient = coreStart.elasticsearch.client.asInternalUser;
+    const savedObjectsClient = await getInternalSavedObjectsClient(coreStart);
+    try {
+      if (fleetPluginStart) {
+        // create source map as fleet artifact
+        const artifact = await createFleetAndroidMapArtifact({
+          fleetPluginStart,
+          apmArtifactBody: {
+            serviceName,
+            serviceVersion,
+            bundleFilepath: bundleFilePath,
+            sourceMap: sourceMapContent,
+          },
+        });
+
+        // sync source map to APM managed index
+        await createApmAndroidMap({
+          internalESClient,
+          logger,
+          fleetId: artifact.id,
+          created: artifact.created,
+          mapContent: sourceMapContent,
+          bundleFilepath: bundleFilePath.toString(),
+          serviceName,
+          serviceVersion,
+        });
+
+        // sync source map to fleet policy
+        await updateSourceMapsOnFleetPolicies({
+          coreStart,
+          fleetPluginStart,
+          savedObjectsClient:
+            savedObjectsClient as unknown as SavedObjectsClientContract,
+          internalESClient,
+        });
+
+        return artifact;
+      }
+    } catch (e) {
+      throw Boom.internal(
+        'Something went wrong while creating a new android map',
+        e
+      );
+    }
+  },
+});
+
 const deleteSourceMapRoute = createApmServerRoute({
   endpoint: 'DELETE /api/apm/sourcemaps/{id} 2023-10-31',
   options: { tags: ['access:apm', 'access:apm_write'] },
@@ -230,5 +332,6 @@ export const sourceMapsRouteRepository = {
   ...listSourceMapRoute,
   ...uploadSourceMapRoute,
   ...deleteSourceMapRoute,
+  ...uploadAndroidMapRoute,
   ...migrateFleetArtifactsSourceMapRoute,
 };

x-pack/plugins/apm/server/routes/source_maps/sourcemap_utils.ts

@@ -16,8 +16,11 @@ function asSha256Encoded(content: BinaryLike): string {
   return createHash('sha256').update(content).digest('hex');
 }
 
-export async function getEncodedContent(sourceMapContent: SourceMap) {
-  const contentBuffer = Buffer.from(JSON.stringify(sourceMapContent));
+export async function getEncodedSourceMapContent(sourceMapContent: SourceMap) {
+  return getEncodedContent(JSON.stringify(sourceMapContent));
+}
+export async function getEncodedContent(textContent: string) {
+  const contentBuffer = Buffer.from(textContent);
   const contentZipped = await deflateAsync(contentBuffer);
   const contentEncoded = contentZipped.toString('base64');
   const contentHash = asSha256Encoded(contentZipped);