[Reporting/Cloud] Soft disable reporting functionality on 1GB Kibanas

packages/kbn-doc-links/src/get_doc_links.ts

@@ -459,6 +459,9 @@ export const getDocLinks = ({ kibanaBranch }: GetDocLinkOptions): DocLinks => {
       monitorLogstash: `${ELASTIC_WEBSITE_URL}guide/en/logstash/${DOC_LINK_VERSION}/monitoring-with-metricbeat.html`,
       troubleshootKibana: `${KIBANA_DOCS}monitor-troubleshooting.html`,
     },
+    reporting: {
+      cloudMinimumRequirements: `${KIBANA_DOCS}reporting-getting-started.html#reporting-on-cloud-resource-requirements`,
+    },
     security: {
       apiKeyServiceSettings: `${ELASTICSEARCH_DOCS}security-settings.html#api-key-service-settings`,
       clusterPrivileges: `${ELASTICSEARCH_DOCS}security-privileges.html#privileges-list-cluster`,

packages/kbn-doc-links/src/types.ts

@@ -310,6 +310,9 @@ export interface DocLinks {
     gdalTutorial: string;
   }>;
   readonly monitoring: Record<string, string>;
+  readonly reporting: Readonly<{
+    cloudMinimumRequirements: string;
+  }>;
   readonly security: Readonly<{
     apiKeyServiceSettings: string;
     clusterPrivileges: string;

x-pack/plugins/cloud/server/env.ts

@@ -0,0 +1,15 @@
+/*
+ * 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.
+ */
+
+// Best effort to get instance size from process.env
+export function readInstanceSizeMb(): undefined | number {
+  const capacityString = process.env.CLOUD_KIBANA_CAPACITY;
+  if (capacityString) {
+    const instanceSizeMb = parseInt(capacityString, 10);
+    return isNaN(instanceSizeMb) ? undefined : instanceSizeMb;
+  }
+}

x-pack/plugins/cloud/server/plugin.ts

@@ -14,6 +14,7 @@ import { getIsCloudEnabled } from '../common/is_cloud_enabled';
 import { parseDeploymentIdFromDeploymentUrl } from './utils';
 import { registerFullstoryRoute } from './routes/fullstory';
 import { registerChatRoute } from './routes/chat';
+import { readInstanceSizeMb } from './env';
 
 interface PluginsSetup {
   usageCollection?: UsageCollectionSetup;
@@ -24,6 +25,7 @@ export interface CloudSetup {
   cloudId?: string;
   deploymentId?: string;
   isCloudEnabled: boolean;
+  instanceSizeMb?: number;
   apm: {
     url?: string;
     secretToken?: string;
@@ -41,7 +43,7 @@ export class CloudPlugin implements Plugin<CloudSetup> {
     this.isDev = this.context.env.mode.dev;
   }
 
-  public setup(core: CoreSetup, { usageCollection, security }: PluginsSetup) {
+  public setup(core: CoreSetup, { usageCollection, security }: PluginsSetup): CloudSetup {
     this.logger.debug('Setting up Cloud plugin');
     const isCloudEnabled = getIsCloudEnabled(this.config.id);
     registerCloudUsageCollector(usageCollection, { isCloudEnabled });
@@ -64,6 +66,7 @@ export class CloudPlugin implements Plugin<CloudSetup> {
 
     return {
       cloudId: this.config.id,
+      instanceSizeMb: readInstanceSizeMb(),
       deploymentId: parseDeploymentIdFromDeploymentUrl(this.config.deployment_url),
       isCloudEnabled,
       apm: {

x-pack/plugins/reporting/common/errors/errors.test.ts

@@ -7,7 +7,9 @@
 
 import * as errors from '.';
 
-describe('ReportingError', () => {
+const { ReportingError: _, ...nonAbstractErrors } = errors;
+
+describe('Reporting error', () => {
   it('provides error code when stringified', () => {
     expect(new errors.AuthenticationExpiredError() + '').toBe(
       `ReportingError(code: authentication_expired_error)`
@@ -18,10 +20,14 @@ describe('ReportingError', () => {
       `ReportingError(code: authentication_expired_error) "some details"`
     );
   });
-  it('has the expected code structure', () => {
-    const { ReportingError: _, ...nonAbstractErrors } = errors;
+  it('has the expected error code structure', () => {
+    Object.values(nonAbstractErrors).forEach((Ctor) => {
+      expect(Ctor.code).toMatch(/^[a-z_]+_error$/);
+    });
+  });
+  it('has the same error code values on static "code" and instance "code" properties', () => {
     Object.values(nonAbstractErrors).forEach((Ctor) => {
-      expect(new Ctor().code).toMatch(/^[a-z_]+_error$/);
+      expect(Ctor.code).toBe(new Ctor().code);
     });
   });
 });

x-pack/plugins/reporting/common/errors/index.ts

@@ -15,7 +15,7 @@ export abstract class ReportingError extends Error {
    *
    * @note Convention for codes: lower-case, snake-case and end in `_error`.
    */
-  public abstract code: string;
+  public abstract get code(): string;
 
   constructor(public details?: string) {
     super();
@@ -38,22 +38,34 @@ export abstract class ReportingError extends Error {
  * access token expired.
  */
 export class AuthenticationExpiredError extends ReportingError {
-  code = 'authentication_expired_error';
+  static code = 'authentication_expired_error' as const;
+  public get code(): string {
+    return AuthenticationExpiredError.code;
+  }
 }
 
 export class QueueTimeoutError extends ReportingError {
-  code = 'queue_timeout_error';
+  static code = 'queue_timeout_error' as const;
+  public get code(): string {
+    return QueueTimeoutError.code;
+  }
 }
 
 /**
  * An unknown error has occurred. See details.
  */
 export class UnknownError extends ReportingError {
-  code = 'unknown_error';
+  static code = 'unknown_error' as const;
+  public get code(): string {
+    return UnknownError.code;
+  }
 }
 
 export class PdfWorkerOutOfMemoryError extends ReportingError {
-  code = 'pdf_worker_out_of_memory_error';
+  static code = 'pdf_worker_out_of_memory_error' as const;
+  public get code(): string {
+    return PdfWorkerOutOfMemoryError.code;
+  }
 
   details = i18n.translate('xpack.reporting.common.pdfWorkerOutOfMemoryErrorMessage', {
     defaultMessage:
@@ -70,7 +82,10 @@ export class PdfWorkerOutOfMemoryError extends ReportingError {
 }
 
 export class BrowserCouldNotLaunchError extends ReportingError {
-  code = 'browser_could_not_launch_error';
+  static code = 'browser_could_not_launch_error' as const;
+  public get code(): string {
+    return BrowserCouldNotLaunchError.code;
+  }
 
   details = i18n.translate('xpack.reporting.common.browserCouldNotLaunchErrorMessage', {
     defaultMessage: 'Cannot generate screenshots because the browser did not launch.',
@@ -86,13 +101,42 @@ export class BrowserCouldNotLaunchError extends ReportingError {
 }
 
 export class BrowserUnexpectedlyClosedError extends ReportingError {
-  code = 'browser_unexpectedly_closed_error';
+  static code = 'browser_unexpectedly_closed_error' as const;
+  public get code(): string {
+    return BrowserUnexpectedlyClosedError.code;
+  }
 }
 
 export class BrowserScreenshotError extends ReportingError {
-  code = 'browser_screenshot_error';
+  static code = 'browser_screenshot_error' as const;
+  public get code(): string {
+    return BrowserScreenshotError.code;
+  }
 }
 
 export class KibanaShuttingDownError extends ReportingError {
-  code = 'kibana_shutting_down_error';
+  static code = 'kibana_shutting_down_error' as const;
+  public get code(): string {
+    return KibanaShuttingDownError.code;
+  }
+}
+
+/**
+ * Special error case that should only occur on Cloud when trying to generate
+ * a report on a Kibana instance that is too small to be running Chromium.
+ */
+export class VisualReportingSoftDisabledError extends ReportingError {
+  static code = 'visual_reporting_soft_disabled_error' as const;
+  public get code(): string {
+    return VisualReportingSoftDisabledError.code;
+  }
+
+  details = i18n.translate('xpack.reporting.common.cloud.insufficientSystemMemoryError', {
+    defaultMessage:
+      'This report cannot be generated because Kibana does not have sufficient memory.',
+  });
+
+  public override get message() {
+    return this.details;
+  }
 }

x-pack/plugins/reporting/common/errors/map_to_reporting_error.ts

@@ -13,6 +13,7 @@ import {
   BrowserUnexpectedlyClosedError,
   BrowserScreenshotError,
   PdfWorkerOutOfMemoryError,
+  VisualReportingSoftDisabledError,
 } from '.';
 
 export function mapToReportingError(error: unknown): ReportingError {
@@ -28,6 +29,8 @@ export function mapToReportingError(error: unknown): ReportingError {
       return new BrowserCouldNotLaunchError();
     case error instanceof errors.PdfWorkerOutOfMemoryError:
       return new PdfWorkerOutOfMemoryError();
+    case error instanceof errors.InsufficientMemoryAvailableOnCloudError:
+      return new VisualReportingSoftDisabledError();
   }
   return new UnknownError();
 }

x-pack/plugins/reporting/common/types/index.ts

@@ -156,6 +156,7 @@ export interface JobSummary {
   status: JobStatus;
   jobtype: ReportSource['jobtype'];
   title: ReportSource['payload']['title'];
+  errorCode?: ReportOutput['error_code'];
   maxSizeReached: TaskRunResult['max_size_reached'];
   csvContainsFormulas: TaskRunResult['csv_contains_formulas'];
 }

x-pack/plugins/reporting/public/lib/job.tsx

@@ -61,6 +61,8 @@ export class Job {
 
   public locatorParams?: BaseParamsV2['locatorParams'];
 
+  public error_code?: ReportOutput['error_code'];
+
   constructor(report: ReportApiJSON) {
     this.id = report.id;
     this.index = report.index;
@@ -90,6 +92,7 @@ export class Job {
     this.csv_contains_formulas = report.output?.csv_contains_formulas;
     this.max_size_reached = report.output?.max_size_reached;
     this.warnings = report.output?.warnings;
+    this.error_code = report.output?.error_code;
     this.locatorParams = (report.payload as BaseParamsV2).locatorParams;
     this.metrics = report.metrics;
   }