[Reporting/New Platform] Use the logger service from core

x-pack/legacy/plugins/reporting/export_types/csv/server/execute_job.ts

@@ -5,25 +5,26 @@
  */
 
 import { i18n } from '@kbn/i18n';
+import { CSV_JOB_TYPE } from '../../../common/constants';
+import { cryptoFactory } from '../../../server/lib';
 import {
-  ExecuteJobFactory,
   ESQueueWorkerExecuteFn,
+  ExecuteJobFactory,
   FieldFormats,
+  Logger,
   ServerFacade,
 } from '../../../types';
-import { CSV_JOB_TYPE, PLUGIN_ID } from '../../../common/constants';
-import { cryptoFactory, LevelLogger } from '../../../server/lib';
 import { JobDocPayloadDiscoverCsv } from '../types';
-import { createGenerateCsv } from './lib/generate_csv';
 import { fieldFormatMapFactory } from './lib/field_format_map';
+import { createGenerateCsv } from './lib/generate_csv';
 
 export const executeJobFactory: ExecuteJobFactory<ESQueueWorkerExecuteFn<
   JobDocPayloadDiscoverCsv
->> = function executeJobFactoryFn(server: ServerFacade) {
+>> = function executeJobFactoryFn(server: ServerFacade, parentLogger: Logger) {
   const { callWithRequest } = server.plugins.elasticsearch.getCluster('data');
   const crypto = cryptoFactory(server);
   const config = server.config();
-  const logger = LevelLogger.createForServer(server, [PLUGIN_ID, CSV_JOB_TYPE, 'execute-job']);
+  const logger = parentLogger.clone([CSV_JOB_TYPE, 'execute-job']);
   const serverBasePath = config.get('server.basePath');
 
   return async function executeJob(

x-pack/legacy/plugins/reporting/export_types/csv_from_savedobject/server/create_job/create_job.ts

@@ -6,13 +6,14 @@
 
 import { notFound, notImplemented } from 'boom';
 import { get } from 'lodash';
-import { PLUGIN_ID, CSV_FROM_SAVEDOBJECT_JOB_TYPE } from '../../../../common/constants';
-import { cryptoFactory, LevelLogger } from '../../../../server/lib';
+import { CSV_FROM_SAVEDOBJECT_JOB_TYPE } from '../../../../common/constants';
+import { cryptoFactory } from '../../../../server/lib';
 import {
   CreateJobFactory,
   ImmediateCreateJobFn,
   ServerFacade,
   RequestFacade,
+  Logger,
 } from '../../../../types';
 import {
   SavedObject,
@@ -34,13 +35,9 @@ interface VisData {
 
 export const createJobFactory: CreateJobFactory<ImmediateCreateJobFn<
   JobParamsPanelCsv
->> = function createJobFactoryFn(server: ServerFacade) {
+>> = function createJobFactoryFn(server: ServerFacade, parentLogger: Logger) {
   const crypto = cryptoFactory(server);
-  const logger = LevelLogger.createForServer(server, [
-    PLUGIN_ID,
-    CSV_FROM_SAVEDOBJECT_JOB_TYPE,
-    'create-job',
-  ]);
+  const logger = parentLogger.clone([CSV_FROM_SAVEDOBJECT_JOB_TYPE, 'create-job']);
 
   return async function createJob(
     jobParams: JobParamsPanelCsv,

x-pack/legacy/plugins/reporting/export_types/csv_from_savedobject/server/execute_job.ts

@@ -5,32 +5,25 @@
  */
 
 import { i18n } from '@kbn/i18n';
-import { cryptoFactory, LevelLogger } from '../../../server/lib';
+import { CONTENT_TYPE_CSV, CSV_FROM_SAVEDOBJECT_JOB_TYPE } from '../../../common/constants';
+import { cryptoFactory } from '../../../server/lib';
 import {
   ExecuteJobFactory,
   ImmediateExecuteFn,
   JobDocOutputExecuted,
-  ServerFacade,
+  Logger,
   RequestFacade,
+  ServerFacade,
 } from '../../../types';
-import {
-  CONTENT_TYPE_CSV,
-  CSV_FROM_SAVEDOBJECT_JOB_TYPE,
-  PLUGIN_ID,
-} from '../../../common/constants';
 import { CsvResultFromSearch } from '../../csv/types';
-import { JobParamsPanelCsv, SearchPanel, JobDocPayloadPanelCsv, FakeRequest } from '../types';
+import { FakeRequest, JobDocPayloadPanelCsv, JobParamsPanelCsv, SearchPanel } from '../types';
 import { createGenerateCsv } from './lib';
 
 export const executeJobFactory: ExecuteJobFactory<ImmediateExecuteFn<
   JobParamsPanelCsv
->> = function executeJobFactoryFn(server: ServerFacade) {
+>> = function executeJobFactoryFn(server: ServerFacade, parentLogger: Logger) {
   const crypto = cryptoFactory(server);
-  const logger = LevelLogger.createForServer(server, [
-    PLUGIN_ID,
-    CSV_FROM_SAVEDOBJECT_JOB_TYPE,
-    'execute-job',
-  ]);
+  const logger = parentLogger.clone([CSV_FROM_SAVEDOBJECT_JOB_TYPE, 'execute-job']);
 
   return async function executeJob(
     jobId: string | null,

x-pack/legacy/plugins/reporting/export_types/png/server/execute_job/index.ts

@@ -6,14 +6,14 @@
 
 import * as Rx from 'rxjs';
 import { catchError, map, mergeMap, takeUntil } from 'rxjs/operators';
-import { PLUGIN_ID, PNG_JOB_TYPE } from '../../../../common/constants';
+import { PNG_JOB_TYPE } from '../../../../common/constants';
 import {
   ServerFacade,
   ExecuteJobFactory,
   ESQueueWorkerExecuteFn,
   HeadlessChromiumDriverFactory,
+  Logger,
 } from '../../../../types';
-import { LevelLogger } from '../../../../server/lib';
 import {
   decryptJobHeaders,
   omitBlacklistedHeaders,
@@ -27,10 +27,11 @@ type QueuedPngExecutorFactory = ExecuteJobFactory<ESQueueWorkerExecuteFn<JobDocP
 
 export const executeJobFactory: QueuedPngExecutorFactory = function executeJobFactoryFn(
   server: ServerFacade,
+  parentLogger: Logger,
   { browserDriverFactory }: { browserDriverFactory: HeadlessChromiumDriverFactory }
 ) {
   const generatePngObservable = generatePngObservableFactory(server, browserDriverFactory);
-  const logger = LevelLogger.createForServer(server, [PLUGIN_ID, PNG_JOB_TYPE, 'execute']);
+  const logger = parentLogger.clone([PNG_JOB_TYPE, 'execute']);
 
   return function executeJob(jobId: string, job: JobDocPayloadPNG, cancellationToken: any) {
     const jobLogger = logger.clone([jobId]);

x-pack/legacy/plugins/reporting/export_types/printable_pdf/server/execute_job/index.ts

@@ -11,10 +11,10 @@ import {
   ExecuteJobFactory,
   ESQueueWorkerExecuteFn,
   HeadlessChromiumDriverFactory,
+  Logger,
 } from '../../../../types';
 import { JobDocPayloadPDF } from '../../types';
-import { PLUGIN_ID, PDF_JOB_TYPE } from '../../../../common/constants';
-import { LevelLogger } from '../../../../server/lib';
+import { PDF_JOB_TYPE } from '../../../../common/constants';
 import { generatePdfObservableFactory } from '../lib/generate_pdf';
 import {
   decryptJobHeaders,
@@ -28,10 +28,11 @@ type QueuedPdfExecutorFactory = ExecuteJobFactory<ESQueueWorkerExecuteFn<JobDocP
 
 export const executeJobFactory: QueuedPdfExecutorFactory = function executeJobFactoryFn(
   server: ServerFacade,
+  parentLogger: Logger,
   { browserDriverFactory }: { browserDriverFactory: HeadlessChromiumDriverFactory }
 ) {
   const generatePdfObservable = generatePdfObservableFactory(server, browserDriverFactory);
-  const logger = LevelLogger.createForServer(server, [PLUGIN_ID, PDF_JOB_TYPE, 'execute']);
+  const logger = parentLogger.clone([PDF_JOB_TYPE, 'execute']);
 
   return function executeJob(jobId: string, job: JobDocPayloadPDF, cancellationToken: any) {
     const jobLogger = logger.clone([jobId]);

x-pack/legacy/plugins/reporting/index.ts

@@ -83,10 +83,10 @@ export const reporting = (kibana: any) => {
         uiSettingsServiceFactory: server.uiSettingsServiceFactory,
         // @ts-ignore Property 'fieldFormatServiceFactory' does not exist on type 'Server'.
         fieldFormatServiceFactory: server.fieldFormatServiceFactory,
-        log: server.log.bind(server),
       };
 
-      const plugin: ReportingPlugin = reportingPluginFactory(__LEGACY, this);
+      const initializerContext = server.newPlatform.coreContext;
+      const plugin: ReportingPlugin = reportingPluginFactory(initializerContext, __LEGACY, this);
       await plugin.setup(coreSetup, pluginsSetup);
     },
 

x-pack/legacy/plugins/reporting/server/browsers/create_browser_driver_factory.ts

@@ -6,17 +6,16 @@
 
 import { ensureBrowserDownloaded } from './download';
 import { installBrowser } from './install';
-import { LevelLogger } from '../lib/level_logger';
-import { ServerFacade, CaptureConfig } from '../../types';
-import { PLUGIN_ID, BROWSER_TYPE } from '../../common/constants';
+import { ServerFacade, CaptureConfig, Logger } from '../../types';
+import { BROWSER_TYPE } from '../../common/constants';
 import { chromium } from './index';
 import { HeadlessChromiumDriverFactory } from './chromium/driver_factory';
 
 export async function createBrowserDriverFactory(
-  server: ServerFacade
+  server: ServerFacade,
+  logger: Logger
 ): Promise<HeadlessChromiumDriverFactory> {
   const config = server.config();
-  const logger = LevelLogger.createForServer(server, [PLUGIN_ID, 'browser-driver']);
 
   const dataDir: string = config.get('path.data');
   const captureConfig: CaptureConfig = config.get('xpack.reporting.capture');

x-pack/legacy/plugins/reporting/server/lib/create_queue.ts

@@ -4,17 +4,16 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { PLUGIN_ID } from '../../common/constants';
 import {
   ServerFacade,
   ExportTypesRegistry,
   HeadlessChromiumDriverFactory,
   QueueConfig,
+  Logger,
 } from '../../types';
 // @ts-ignore
 import { Esqueue } from './esqueue';
 import { createWorkerFactory } from './create_worker';
-import { LevelLogger } from './level_logger';
 import { createTaggedLogger } from './create_tagged_logger'; // TODO remove createTaggedLogger once esqueue is removed
 
 interface CreateQueueFactoryOpts {
@@ -24,6 +23,7 @@ interface CreateQueueFactoryOpts {
 
 export function createQueueFactory(
   server: ServerFacade,
+  logger: Logger,
   { exportTypesRegistry, browserDriverFactory }: CreateQueueFactoryOpts
 ): Esqueue {
   const queueConfig: QueueConfig = server.config().get('xpack.reporting.queue');
@@ -34,23 +34,25 @@ export function createQueueFactory(
     timeout: queueConfig.timeout,
     dateSeparator: '.',
     client: server.plugins.elasticsearch.getCluster('admin'),
-    logger: createTaggedLogger(server, [PLUGIN_ID, 'esqueue', 'queue-worker']),
+    logger: createTaggedLogger(logger, ['esqueue', 'queue-worker']),
   };
 
   const queue: Esqueue = new Esqueue(index, queueOptions);
 
   if (queueConfig.pollEnabled) {
     // create workers to poll the index for idle jobs waiting to be claimed and executed
-    const createWorker = createWorkerFactory(server, { exportTypesRegistry, browserDriverFactory });
+    const createWorker = createWorkerFactory(server, logger, {
+      exportTypesRegistry,
+      browserDriverFactory,
+    });
     createWorker(queue);
   } else {
-    const logger = LevelLogger.createForServer(server, [PLUGIN_ID, 'create_queue']);
     logger.info(
       'xpack.reporting.queue.pollEnabled is set to false. This Kibana instance ' +
         'will not poll for idle jobs to claim and execute. Make sure another ' +
         'Kibana instance with polling enabled is running in this cluster so ' +
         'reporting jobs can complete.',
-      ['info']
+      ['create_queue']
     );
   }
 

x-pack/legacy/plugins/reporting/server/lib/create_tagged_logger.ts

@@ -4,23 +4,23 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
-import { ServerFacade } from '../../types';
+import { Logger } from '../../types';
 
-/**
- * @function taggedLogger
- * @param {string} message
- * @param {string[]} [additionalTags]
- */
-
-/**
- * Creates a taggedLogger function with tags, allows the consumer to optionally provide additional tags
- *
- * @param {Server} server
- * @param {string[]} tags - tags to always be passed into the `logger` function
- * @returns taggedLogger
- */
-export function createTaggedLogger(server: ServerFacade, tags: string[]) {
+export function createTaggedLogger(logger: Logger, tags: string[]) {
   return (msg: string, additionalTags = []) => {
-    server.log([...tags, ...additionalTags], msg);
+    const allTags = [...tags, ...additionalTags];
+
+    if (allTags.includes('info')) {
+      const newTags = allTags.filter(t => t !== 'info'); // Ensure 'info' is not included twice
+      logger.info(msg, newTags);
+    } else if (allTags.includes('debug')) {
+      const newTags = allTags.filter(t => t !== 'debug');
+      logger.debug(msg, newTags);
+    } else if (allTags.includes('warn') || allTags.includes('warning')) {
+      const newTags = allTags.filter(t => t !== 'warn' && t !== 'warning');
+      logger.warn(msg, newTags);
+    } else {
+      logger.error(msg, allTags);
+    }
   };
 }

x-pack/legacy/plugins/reporting/server/lib/create_worker.test.ts

@@ -25,10 +25,11 @@ const executeJobFactoryStub = sinon.stub();
 
 const getMockServer = (): ServerFacade => {
   return ({
-    log: sinon.stub(),
     config: () => ({ get: configGetStub }),
   } as unknown) as ServerFacade;
 };
+const getMockLogger = jest.fn();
+
 const getMockExportTypesRegistry = (
   exportTypes: any[] = [{ executeJobFactory: executeJobFactoryStub }]
 ) => ({
@@ -47,7 +48,7 @@ describe('Create Worker', () => {
 
   test('Creates a single Esqueue worker for Reporting', async () => {
     const exportTypesRegistry = getMockExportTypesRegistry();
-    const createWorker = createWorkerFactory(getMockServer(), {
+    const createWorker = createWorkerFactory(getMockServer(), getMockLogger(), {
       exportTypesRegistry: exportTypesRegistry as ExportTypesRegistry,
       browserDriverFactory: {} as HeadlessChromiumDriverFactory,
     });
@@ -81,7 +82,7 @@ Object {
       { executeJobFactory: executeJobFactoryStub },
       { executeJobFactory: executeJobFactoryStub },
     ]);
-    const createWorker = createWorkerFactory(getMockServer(), {
+    const createWorker = createWorkerFactory(getMockServer(), getMockLogger(), {
       exportTypesRegistry: exportTypesRegistry as ExportTypesRegistry,
       browserDriverFactory: {} as HeadlessChromiumDriverFactory,
     });

x-pack/legacy/plugins/reporting/server/lib/create_worker.ts

@@ -17,10 +17,10 @@ import {
   JobSource,
   RequestFacade,
   ServerFacade,
+  Logger,
 } from '../../types';
 // @ts-ignore untyped dependency
 import { events as esqueueEvents } from './esqueue';
-import { LevelLogger } from './level_logger';
 
 interface CreateWorkerFactoryOpts {
   exportTypesRegistry: ExportTypesRegistry;
@@ -29,11 +29,11 @@ interface CreateWorkerFactoryOpts {
 
 export function createWorkerFactory<JobParamsType>(
   server: ServerFacade,
+  logger: Logger,
   { exportTypesRegistry, browserDriverFactory }: CreateWorkerFactoryOpts
 ) {
   type JobDocPayloadType = JobDocPayload<JobParamsType>;
   const config = server.config();
-  const logger = LevelLogger.createForServer(server, [PLUGIN_ID, 'queue-worker']);
   const queueConfig: QueueConfig = config.get('xpack.reporting.queue');
   const kibanaName: string = config.get('server.name');
   const kibanaId: string = config.get('server.uuid');
@@ -50,7 +50,7 @@ export function createWorkerFactory<JobParamsType>(
       ExportTypeDefinition<JobParamsType, any, any, any>
     >) {
       // TODO: the executeJobFn should be unwrapped in the register method of the export types registry
-      const jobExecutor = exportType.executeJobFactory(server, { browserDriverFactory });
+      const jobExecutor = exportType.executeJobFactory(server, logger, { browserDriverFactory });
       jobExecutors.set(exportType.jobType, jobExecutor);
     }
 

x-pack/legacy/plugins/reporting/server/lib/enqueue_job.ts

@@ -35,16 +35,17 @@ interface EnqueueJobFactoryOpts {
 
 export function enqueueJobFactory(
   server: ServerFacade,
+  parentLogger: Logger,
   { exportTypesRegistry, esqueue }: EnqueueJobFactoryOpts
 ): EnqueueJobFn {
+  const logger = parentLogger.clone(['queue-job']);
   const config = server.config();
   const captureConfig: CaptureConfig = config.get('xpack.reporting.capture');
   const browserType = captureConfig.browser.type;
   const maxAttempts = captureConfig.maxAttempts;
   const queueConfig: QueueConfig = config.get('xpack.reporting.queue');
 
   return async function enqueueJob<JobParamsType>(
-    parentLogger: Logger,
     exportTypeId: string,
     jobParams: JobParamsType,
     user: string,
@@ -53,15 +54,14 @@ export function enqueueJobFactory(
   ): Promise<Job> {
     type CreateJobFn = ESQueueCreateJobFn<JobParamsType> | ImmediateCreateJobFn<JobParamsType>;
 
-    const logger = parentLogger.clone(['queue-job']);
     const exportType = exportTypesRegistry.getById(exportTypeId);
 
     if (exportType == null) {
       throw new Error(`Export type ${exportTypeId} does not exist in the registry!`);
     }
 
     // TODO: the createJobFn should be unwrapped in the register method of the export types registry
-    const createJob = exportType.createJobFactory(server) as CreateJobFn;
+    const createJob = exportType.createJobFactory(server, logger) as CreateJobFn;
     const payload = await createJob(jobParams, headers, request);
 
     const options = {