Adds support for log rotation

docs/setup/settings.asciidoc

@@ -147,6 +147,36 @@ will default to `true`.
 `logging.quiet:`:: *Default: false* Set the value of this setting to `true` to
 suppress all logging output other than error messages.
 
+`logging.rotate:`:: [experimental] Specifies the options for the logging rotate feature.
+When not defined, all the sub options defaults would be applied.
+The following example shows a valid logging rotate configuration:
++
+--
+    logging.rotate:
+      enabled: true
+      everyBytes: 10485760
+      keepFiles: 10
+--
+
+`logging.rotate.enabled:`:: [experimental] *Default: false* Set the value of this setting to `true` to
+enable log rotation. If you do not have a `logging.dest` set that is different from `stdout`
+that feature would not take any effect.
+
+`logging.rotate.everyBytes:`:: [experimental] *Default: 10485760* The maximum size of a log file (that is `not an exact` limit). After the 
+limit is reached, a new log file is generated. The default size limit is 10485760 (10 MB) and
+this option should be at least greater than 1024.
+
+`logging.rotate.keepFiles:`:: [experimental] *Default: 7* The number of most recent rotated log files to keep 
+on disk. Older files are deleted during log rotation. The default value is 7. The `logging.rotate.keepFiles` 
+option has to be in the range of 2 to 1024 files.
+
+`logging.rotate.pollingInterval:`:: [experimental] *Default: 10000* The number of milliseconds for the polling strategy in case 
+the `logging.rotate.usePolling` is enabled. That option has to be in the range of 5000 to 3600000 milliseconds.
+
+`logging.rotate.usePolling:`:: [experimental] *Default: false* By default we try to understand the best way to monitoring 
+the log file. However, there is some systems where it could not be always accurate. In those cases, if needed, 
+the `polling` method could be used enabling that option.
+
 `logging.silent:`:: *Default: false* Set the value of this setting to `true` to
 suppress all logging output.
 

package.json

@@ -149,6 +149,7 @@
     "cache-loader": "^4.1.0",
     "chalk": "^2.4.2",
     "check-disk-space": "^2.1.0",
+    "chokidar": "3.2.1",
     "color": "1.0.3",
     "commander": "3.0.0",
     "compare-versions": "3.5.1",
@@ -370,7 +371,6 @@
     "chai": "3.5.0",
     "chance": "1.0.18",
     "cheerio": "0.22.0",
-    "chokidar": "3.2.1",
     "chromedriver": "78.0.1",
     "classnames": "2.2.6",
     "dedent": "^0.7.0",

src/cli/cluster/cluster_manager.js

@@ -90,6 +90,18 @@ export default class ClusterManager {
       });
     });
 
+    // When receive that event from server worker
+    // forward a reloadLoggingConfig message to master
+    // and all workers. This is only used by LogRotator service
+    // when the cluster mode is enabled
+    this.server.on('reloadLoggingConfigFromServerWorker', () => {
+      process.emit('message', { reloadLoggingConfig: true });
+
+      this.workers.forEach(worker => {
+        worker.fork.send({ reloadLoggingConfig: true });
+      });
+    });
+
     bindAll(this, 'onWatcherAdd', 'onWatcherError', 'onWatcherChange');
 
     if (opts.open) {

src/cli/cluster/worker.js

@@ -134,6 +134,9 @@ export default class Worker extends EventEmitter {
         this.listening = true;
         this.emit('listening');
         break;
+      case 'RELOAD_LOGGING_CONFIG_FROM_SERVER_WORKER':
+        this.emit('reloadLoggingConfigFromServerWorker');
+        break;
     }
   }
 

src/core/server/bootstrap.ts

@@ -71,7 +71,20 @@ export async function bootstrap({
 
   const root = new Root(rawConfigService.getConfig$(), env, onRootShutdown);
 
-  process.on('SIGHUP', () => {
+  process.on('SIGHUP', () => reloadLoggingConfig());
+
+  // This is only used by the LogRotator service
+  // in order to be able to reload the log configuration
+  // under the cluster mode
+  process.on('message', msg => {
+    if (!msg || msg.reloadLoggingConfig !== true) {
+      return;
+    }
+
+    reloadLoggingConfig();
+  });
+
+  function reloadLoggingConfig() {
     const cliLogger = root.logger.get('cli');
     cliLogger.info('Reloading logging configuration due to SIGHUP.', { tags: ['config'] });
 
@@ -82,7 +95,7 @@ export async function bootstrap({
     }
 
     cliLogger.info('Reloaded logging configuration due to SIGHUP.', { tags: ['config'] });
-  });
+  }
 
   process.on('SIGINT', () => shutdown());
   process.on('SIGTERM', () => shutdown());

src/core/server/logging/logging_service.test.ts

@@ -23,6 +23,10 @@ jest.mock('fs', () => ({
   createWriteStream: jest.fn(() => ({ write: mockStreamWrite })),
 }));
 
+jest.mock('../../../legacy/server/logging/rotate', () => ({
+  setupLoggingRotate: jest.fn().mockImplementation(() => Promise.resolve({})),
+}));
+
 const timestamp = new Date(Date.UTC(2012, 1, 1));
 let mockConsoleLog: jest.SpyInstance;
 

src/dev/build/tasks/os_packages/docker_generator/resources/bin/kibana-docker

@@ -42,6 +42,11 @@ kibana_vars=(
     kibana.index
     logging.dest
     logging.quiet
+    logging.rotate.enabled
+    logging.rotate.everyBytes
+    logging.rotate.keepFiles
+    logging.rotate.pollingInterval
+    logging.rotate.usePolling
     logging.silent
     logging.useUTC
     logging.verbose

src/legacy/server/config/schema.js

@@ -135,7 +135,14 @@ export default () => Joi.object({
         then: Joi.default(!process.stdout.isTTY),
         otherwise: Joi.default(true)
       }),
-    timezone: Joi.string()
+    timezone: Joi.string(),
+    rotate: Joi.object().keys({
+      enabled: Joi.boolean().default(false),
+      everyBytes: Joi.number().greater(1024).default(10485760),
+      keepFiles: Joi.number().greater(2).less(1024).default(7),
+      pollingInterval: Joi.number().greater(5000).less(3600000).default(10000),
+      usePolling: Joi.boolean().default(false)
+    }).default()
   }).default(),
 
   ops: Joi.object({

src/legacy/server/logging/index.js

@@ -20,6 +20,7 @@
 import good from '@elastic/good';
 import loggingConfiguration from './configuration';
 import { logWithMetadata } from './log_with_metadata';
+import { setupLoggingRotate } from './rotate';
 
 export async function setupLogging(server, config) {
   return await server.register({
@@ -30,5 +31,7 @@ export async function setupLogging(server, config) {
 
 export async function loggingMixin(kbnServer, server, config) {
   logWithMetadata.decorateServer(server);
-  return await setupLogging(server, config);
+
+  await setupLogging(server, config);
+  await setupLoggingRotate(server, config);
 }

src/legacy/server/logging/rotate/index.ts

@@ -0,0 +1,64 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { isMaster, isWorker } from 'cluster';
+import { Server } from 'hapi';
+import { LogRotator } from './log_rotator';
+import { KibanaConfig } from '../../kbn_server';
+
+let logRotator: LogRotator;
+
+export async function setupLoggingRotate(server: Server, config: KibanaConfig) {
+  // If log rotate is not enabled we skip
+  if (!config.get('logging.rotate.enabled')) {
+    return;
+  }
+
+  // We just want to start the logging rotate service once
+  // and we choose to use the master (prod) or the worker server (dev)
+  if (!isMaster && isWorker && process.env.kbnWorkerType !== 'server') {
+    return;
+  }
+
+  // We don't want to run logging rotate server if
+  // we are not logging to a file
+  if (config.get('logging.dest') === 'stdout') {
+    server.log(
+      ['warning', 'logging:rotate'],
+      'Log rotation is enabled but logging.dest is configured for stdout. Set logging.dest to a file for this setting to take effect.'
+    );
+    return;
+  }
+
+  server.log(
+    ['warning', 'logging:rotate'],
+    'Log rotation is enabled but logging.dest is configured for stdout. Set logging.dest to a file for this setting to take effect.'
+  );
+
+  // Enable Logging Rotate Service
+  // We need the master process and it can
+  // try to setupLoggingRotate more than once,
+  // so we'll need to assure it only loads once.
+  if (!logRotator) {
+    logRotator = new LogRotator(config, server);
+    await logRotator.start();
+  }
+
+  return logRotator;
+}