Merge branch 'master' into ml-fix-resize

docs/development/core/public/kibana-plugin-public.applicationstart.geturlforapp.md

@@ -4,13 +4,16 @@
 
 ## ApplicationStart.getUrlForApp() method
 
-Returns a relative URL to a given app, including the global base path.
+Returns an URL to a given app, including the global base path. By default, the URL is relative (/basePath/app/my-app). Use the `absolute` option to generate an absolute url (http://host:port/basePath/app/my-app)
+
+Note that when generating absolute urls, the protocol, host and port are determined from the browser location.
 
 <b>Signature:</b>
 
 ```typescript
 getUrlForApp(appId: string, options?: {
         path?: string;
+        absolute?: boolean;
     }): string;
 ```
 
@@ -19,7 +22,7 @@ getUrlForApp(appId: string, options?: {
 |  Parameter | Type | Description |
 |  --- | --- | --- |
 |  appId | <code>string</code> |  |
-|  options | <code>{</code><br/><code>        path?: string;</code><br/><code>    }</code> |  |
+|  options | <code>{</code><br/><code>        path?: string;</code><br/><code>        absolute?: boolean;</code><br/><code>    }</code> |  |
 
 <b>Returns:</b>
 

docs/development/core/public/kibana-plugin-public.applicationstart.md

@@ -22,7 +22,7 @@ export interface ApplicationStart
 
 |  Method | Description |
 |  --- | --- |
-|  [getUrlForApp(appId, options)](./kibana-plugin-public.applicationstart.geturlforapp.md) | Returns a relative URL to a given app, including the global base path. |
+|  [getUrlForApp(appId, options)](./kibana-plugin-public.applicationstart.geturlforapp.md) | Returns an URL to a given app, including the global base path. By default, the URL is relative (/basePath/app/my-app). Use the <code>absolute</code> option to generate an absolute url (http://host:port/basePath/app/my-app)<!-- -->Note that when generating absolute urls, the protocol, host and port are determined from the browser location. |
 |  [navigateToApp(appId, options)](./kibana-plugin-public.applicationstart.navigatetoapp.md) | Navigate to a given app |
 |  [registerMountContext(contextName, provider)](./kibana-plugin-public.applicationstart.registermountcontext.md) | Register a context provider for application mounting. Will only be available to applications that depend on the plugin that registered this context. Deprecated, use [CoreSetup.getStartServices()](./kibana-plugin-public.coresetup.getstartservices.md)<!-- -->. |
 

docs/logs/using.asciidoc

@@ -8,7 +8,6 @@ You can also view related application traces or uptime information where availab
 
 [role="screenshot"]
 image::logs/images/logs-console.png[Logs Console in Kibana]
-// ++ Update this
 
 [float]
 [[logs-search]]

src/core/MIGRATION.md

@@ -56,6 +56,7 @@
       - [On the server side](#on-the-server-side)
       - [On the client side](#on-the-client-side)
     - [Updates an application navlink at runtime](#updates-an-app-navlink-at-runtime)
+    - [Logging config migration](#logging-config-migration)
 
 Make no mistake, it is going to take a lot of work to move certain plugins to the new platform. Our target is to migrate the entire repo over to the new platform throughout 7.x and to remove the legacy plugin system no later than 8.0, and this is only possible if teams start on the effort now.
 
@@ -1655,4 +1656,7 @@ export class MyPlugin implements Plugin {
        tooltip: 'Application disabled',
      })
   }
-```
+```
+
+### Logging config migration
+[Read](./server/logging/README.md#logging-config-migration)

src/core/public/application/application_service.test.ts

@@ -580,14 +580,23 @@ describe('#start()', () => {
 
     it('creates URLs with path parameter', async () => {
       service.setup(setupDeps);
-
       const { getUrlForApp } = await service.start(startDeps);
 
       expect(getUrlForApp('app1', { path: 'deep/link' })).toBe('/base-path/app/app1/deep/link');
       expect(getUrlForApp('app1', { path: '/deep//link/' })).toBe('/base-path/app/app1/deep/link');
       expect(getUrlForApp('app1', { path: '//deep/link//' })).toBe('/base-path/app/app1/deep/link');
       expect(getUrlForApp('app1', { path: 'deep/link///' })).toBe('/base-path/app/app1/deep/link');
     });
+
+    it('creates absolute URLs when `absolute` parameter is true', async () => {
+      service.setup(setupDeps);
+      const { getUrlForApp } = await service.start(startDeps);
+
+      expect(getUrlForApp('app1', { absolute: true })).toBe('http://localhost/base-path/app/app1');
+      expect(getUrlForApp('app2', { path: 'deep/link', absolute: true })).toBe(
+        'http://localhost/base-path/app/app2/deep/link'
+      );
+    });
   });
 
   describe('navigateToApp', () => {

src/core/public/application/application_service.tsx

@@ -272,8 +272,13 @@ export class ApplicationService {
         takeUntil(this.stop$)
       ),
       registerMountContext: this.mountContext.registerContext,
-      getUrlForApp: (appId, { path }: { path?: string } = {}) =>
-        http.basePath.prepend(getAppUrl(availableMounters, appId, path)),
+      getUrlForApp: (
+        appId,
+        { path, absolute = false }: { path?: string; absolute?: boolean } = {}
+      ) => {
+        const relUrl = http.basePath.prepend(getAppUrl(availableMounters, appId, path));
+        return absolute ? relativeToAbsolute(relUrl) : relUrl;
+      },
       navigateToApp: async (appId, { path, state }: { path?: string; state?: any } = {}) => {
         if (await this.shouldNavigate(overlays)) {
           this.appLeaveHandlers.delete(this.currentAppId$.value!);
@@ -364,3 +369,10 @@ const updateStatus = <T extends AppBase>(app: T, statusUpdaters: AppUpdaterWrapp
     ...changes,
   };
 };
+
+function relativeToAbsolute(url: string) {
+  // convert all link urls to absolute urls
+  const a = document.createElement('a');
+  a.setAttribute('href', url);
+  return a.href;
+}

src/core/public/application/types.ts

@@ -593,11 +593,17 @@ export interface ApplicationStart {
   navigateToApp(appId: string, options?: { path?: string; state?: any }): Promise<void>;
 
   /**
-   * Returns a relative URL to a given app, including the global base path.
+   * Returns an URL to a given app, including the global base path.
+   * By default, the URL is relative (/basePath/app/my-app).
+   * Use the `absolute` option to generate an absolute url (http://host:port/basePath/app/my-app)
+   *
+   * Note that when generating absolute urls, the protocol, host and port are determined from the browser location.
+   *
    * @param appId
    * @param options.path - optional path inside application to deep link to
+   * @param options.absolute - if true, will returns an absolute url instead of a relative one
    */
-  getUrlForApp(appId: string, options?: { path?: string }): string;
+  getUrlForApp(appId: string, options?: { path?: string; absolute?: boolean }): string;
 
   /**
    * Register a context provider for application mounting. Will only be available to applications that depend on the

src/core/public/public.api.md

@@ -101,6 +101,7 @@ export interface ApplicationStart {
     currentAppId$: Observable<string | undefined>;
     getUrlForApp(appId: string, options?: {
         path?: string;
+        absolute?: boolean;
     }): string;
     navigateToApp(appId: string, options?: {
         path?: string;

src/core/server/logging/README.md

@@ -1,4 +1,12 @@
 # Logging
+- [Loggers, Appenders and Layouts](#loggers-appenders-and-layouts)
+- [Logger hierarchy](#logger-hierarchy)
+- [Log level](#log-level)
+- [Layouts](#layouts)
+  - [Pattern layout](#pattern-layout)
+  - [JSON layout](#json-layout)
+- [Configuration](#configuration)
+- [Usage](#usage)
 
 The way logging works in Kibana is inspired by `log4j 2` logging framework used by [Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/settings.html#logging).
 The main idea is to have consistent logging behaviour (configuration, log format etc.) across the entire Elastic Stack 
@@ -52,12 +60,68 @@ custom appenders, so one should always make the choice explicitly.
 
 There are two types of layout supported at the moment: `pattern` and `json`. 
 
-With `pattern` layout it's possible to define a string pattern with special placeholders wrapped into curly braces that
+### Pattern layout
+With `pattern` layout it's possible to define a string pattern with special placeholders `%conversion_pattern` (see the table below) that
 will be replaced with data from the actual log message. By default the following pattern is used: 
-`[{timestamp}][{level}][{context}] {message}`. Also `highlight` option can be enabled for `pattern` layout so that
+`[%date][%level][%logger]%meta %message`. Also `highlight` option can be enabled for `pattern` layout so that
 some parts of the log message are highlighted with different colors that may be quite handy if log messages are forwarded
 to the terminal with color support.
+`pattern` layout uses a sub-set of [log4j2 pattern syntax](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout)
+and **doesn't implement** all `log4j2` capabilities. The conversions that are provided out of the box are:
 
+#### level
+Outputs the [level](#log-level) of the logging event.
+Example of `%level` output:
+```bash
+TRACE
+DEBUG
+INFO
+```
+
+##### logger
+Outputs the name of the logger that published the logging event.
+Example of `%logger` output:
+```bash
+server
+server.http
+server.http.Kibana
+```
+
+#### message
+Outputs the application supplied message associated with the logging event.
+
+#### meta
+Outputs the entries of `meta` object data in **json** format, if one is present in the event.
+Example of `%meta` output:
+```bash
+// Meta{from: 'v7', to: 'v8'}
+'{"from":"v7","to":"v8"}'
+// Meta empty object
+'{}'
+// no Meta provided
+''
+```
+
+##### date
+Outputs the date of the logging event. The date conversion specifier may be followed by a set of braces containing a name of predefined date format and canonical timezone name.
+Timezone name is expected to be one from [TZ database name](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
+Example of `%date` output:
+
+| Conversion pattern                       | Example                                                          |
+| ---------------------------------------- | ---------------------------------------------------------------- |
+| `%date`                                  | `2012-02-01T14:30:22.011Z` uses `ISO8601` format by default      |
+| `%date{ISO8601}`                         | `2012-02-01T14:30:22.011Z`                                       |
+| `%date{ISO8601_TZ}`                      | `2012-02-01T09:30:22.011-05:00`   `ISO8601` with timezone        |
+| `%date{ISO8601_TZ}{America/Los_Angeles}` | `2012-02-01T06:30:22.011-08:00`                                  |
+| `%date{ABSOLUTE}`                        | `09:30:22.011`                                                   |
+| `%date{ABSOLUTE}{America/Los_Angeles}`   | `06:30:22.011`                                                   |
+| `%date{UNIX}`                            | `1328106622`                                                     |
+| `%date{UNIX_MILLIS}`                     | `1328106622011`                                                  |
+
+#### pid
+Outputs the process ID.
+
+### JSON layout
 With `json` layout log messages will be formatted as JSON strings that include timestamp, log level, context, message 
 text and any other metadata that may be associated with the log message itself.
 
@@ -88,7 +152,7 @@ logging:
       kind: console
       layout:
         kind: pattern
-        pattern: [{timestamp}][{level}] {message}
+        pattern: "[%date][%level] %message"
     json-file-appender:
       kind: file
       path: /var/log/kibana-json.log
@@ -179,3 +243,81 @@ The log will be less verbose with `warn` level for the `server` context:
 [2017-07-25T18:54:41.639Z][ERROR][server] Message with `error` log level.
 [2017-07-25T18:54:41.639Z][FATAL][server] Message with `fatal` log level.
 ```
+
+### Logging config migration
+Compatibility with the legacy logging system is assured until the end of the `v7` version.
+All log messages handled by `root` context are forwarded to the legacy logging service. If you re-write
+root appenders, make sure that it contains `default` appender to provide backward compatibility.
+**Note**: If you define an appender for a context, the log messages aren't handled by the
+`root` context anymore and not forwarded to the legacy logging service.
+
+#### logging.dest
+By default logs in *stdout*. With new Kibana logging you can use pre-existing `console` appender or
+define a custom one.
+```yaml
+logging:
+  loggers:
+    - context: your-plugin
+      appenders: [console]
+```
+Logs in a *file* if given file path. You should define a custom appender with `kind: file` 
+```yaml
+
+logging:
+  appenders:
+    file:
+      kind: file
+      path: /var/log/kibana.log
+      layout:
+        kind: pattern
+  loggers:
+    - context: your-plugin
+      appenders: [file]
+``` 
+#### logging.json
+Defines the format of log output. Logs in JSON if `true`. With new logging config you can adjust
+the output format with [layouts](#layouts).
+
+#### logging.quiet
+Suppresses all logging output other than error messages. With new logging, config can be achieved 
+with adjusting minimum required [logging level](#log-level)
+```yaml
+  loggers:
+    - context: my-plugin
+      appenders: [console]
+      level: error
+# or for all output
+logging.root.level: error
+```
+
+#### logging.silent:
+Suppresses all logging output.
+```yaml
+logging.root.level: off
+```
+
+#### logging.verbose:
+Logs all events
+```yaml
+logging.root.level: all
+```
+
+#### logging.timezone
+Set to the canonical timezone id to log events using that timezone. New logging config allows
+to [specify timezone](#date) for `layout: pattern`.
+```yaml
+logging:
+  appenders:
+    custom-console:
+      kind: console
+      layout:
+        kind: pattern
+        highlight: true
+        pattern: "[%level] [%date{ISO8601_TZ}{America/Los_Angeles}][%logger] %message"
+```
+
+#### logging.events
+Define a custom logger for a specific context.
+
+#### logging.filter
+TBD

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

@@ -29,7 +29,7 @@ function createRoot() {
           layout: {
             highlight: false,
             kind: 'pattern',
-            pattern: '{level}|{context}|{message}',
+            pattern: '%level|%logger|%message',
           },
         },
       },

src/core/server/logging/layouts/conversions/timestamp.ts → src/core/server/logging/layouts/conversions/date.ts

@@ -22,7 +22,7 @@ import { last } from 'lodash';
 import { Conversion } from './type';
 import { LogRecord } from '../../log_record';
 
-const timestampRegExp = /{timestamp({(?<format>[^}]+)})?({(?<timezone>[^}]+)})?}/gi;
+const dateRegExp = /%date({(?<format>[^}]+)})?({(?<timezone>[^}]+)})?/g;
 
 const formats = {
   ISO8601: 'ISO8601',
@@ -54,10 +54,11 @@ function formatDate(date: Date, dateFormat: string = formats.ISO8601, timezone?:
 }
 
 function validateDateFormat(input: string) {
-  if (Reflect.has(formats, input)) return;
-  throw new Error(
-    `Date format expected one of ${Reflect.ownKeys(formats).join(', ')}, but given: ${input}`
-  );
+  if (!Reflect.has(formats, input)) {
+    throw new Error(
+      `Date format expected one of ${Reflect.ownKeys(formats).join(', ')}, but given: ${input}`
+    );
+  }
 }
 
 function validateTimezone(timezone: string) {
@@ -66,7 +67,7 @@ function validateTimezone(timezone: string) {
 }
 
 function validate(rawString: string) {
-  for (const matched of rawString.matchAll(timestampRegExp)) {
+  for (const matched of rawString.matchAll(dateRegExp)) {
     const { format, timezone } = matched.groups!;
 
     if (format) {
@@ -78,9 +79,9 @@ function validate(rawString: string) {
   }
 }
 
-export const TimestampConversion: Conversion = {
-  pattern: timestampRegExp,
-  formatter(record: LogRecord, highlight: boolean, ...matched: any[]) {
+export const DateConversion: Conversion = {
+  pattern: dateRegExp,
+  convert(record: LogRecord, highlight: boolean, ...matched: any[]) {
     const groups: Record<string, string | undefined> = last(matched);
     const { format, timezone } = groups;