diff --git a/docs/visualize.asciidoc b/docs/visualize.asciidoc
index 1aa8076d578ea..5412591685701 100644
--- a/docs/visualize.asciidoc
+++ b/docs/visualize.asciidoc
@@ -118,3 +118,5 @@ include::visualize/pie.asciidoc[]
 include::visualize/tilemap.asciidoc[]
 
 include::visualize/vertbar.asciidoc[]
+
+include::visualize/tagcloud.asciidoc[]
diff --git a/docs/visualize/tagcloud.asciidoc b/docs/visualize/tagcloud.asciidoc
new file mode 100644
index 0000000000000..b06e57a722e47
--- /dev/null
+++ b/docs/visualize/tagcloud.asciidoc
@@ -0,0 +1,44 @@
+[[tagcloud-chart]]
+== Cloud Tag Charts
+
+A tag cloud visualization is a visual representation of text data, typically used to visualize free form text. 
+Tags are usually single words, and the importance of each tag is shown with font size or color.
+
+The font size for each word is determined by the _metrics_ aggregation. The following aggregations are available for
+this chart:
+
+include::y-axis-aggs.asciidoc[]
+
+
+The _buckets_ aggregations determine what information is being retrieved from your data set.
+
+Before you choose a buckets aggregation, select the *Split Tags* option.
+
+You can specify the following bucket aggregations for tag cloud visualization:
+
+*Terms*:: A {es-ref}search-aggregations-bucket-terms-aggregation.html[_terms_] aggregation enables you to specify the top
+or bottom _n_ elements of a  given field to display, ordered by count or a custom metric.
+
+You can click the *Advanced* link to display more customization options for your metrics or bucket aggregation:
+
+*JSON Input*:: A text field where you can add specific JSON-formatted properties to merge with the aggregation
+definition, as in the following example:
+
+[source,shell]
+{ "script" : "doc['grade'].value * 1.2" }
+
+NOTE: In Elasticsearch releases 1.4.3 and later, this functionality requires you to enable
+{es-ref}modules-scripting.html[dynamic Groovy scripting].
+
+
+Select the *Options* tab to change the following aspects of the chart:
+
+*Text Scale*:: You can select *linear*, *log*, or *square root* scales for the text scale. You can use a log
+scale to display data that varies exponentially or a square root scale to
+regularize the display of data sets with variabilities that are themselves highly variable.
+*Orientation*:: You can select how to orientate your text in the tag cloud. You can choose one of the following options:
+Single, right angles and multiple.
+*Font Size*:: Allows you to set minimum and maximum font size to use for this visualization.
+
+
+include::visualization-raw-data.asciidoc[]
\ No newline at end of file
diff --git a/package.json b/package.json
index 1380678cc5d74..b26563945552c 100644
--- a/package.json
+++ b/package.json
@@ -101,6 +101,7 @@
     "commander": "2.8.1",
     "css-loader": "0.17.0",
     "d3": "3.5.6",
+    "d3-cloud": "1.2.1",
     "dragula": "3.7.0",
     "elasticsearch": "12.0.0-rc5",
     "elasticsearch-browser": "12.0.0-rc5",
@@ -138,6 +139,7 @@
     "mkdirp": "0.5.1",
     "moment": "2.13.0",
     "moment-timezone": "0.5.4",
+    "no-ui-slider": "1.2.0",
     "node-fetch": "1.3.2",
     "node-uuid": "1.4.7",
     "pegjs": "0.9.0",
diff --git a/src/core_plugins/elasticsearch/lib/__tests__/check_es_version.js b/src/core_plugins/elasticsearch/lib/__tests__/check_es_version.js
index 74d43816d8384..cc36d350d6eb0 100644
--- a/src/core_plugins/elasticsearch/lib/__tests__/check_es_version.js
+++ b/src/core_plugins/elasticsearch/lib/__tests__/check_es_version.js
@@ -56,6 +56,12 @@ describe('plugins/elasticsearch', () => {
       client.nodes.info = sinon.stub().returns(Promise.resolve({ nodes: nodes }));
     }
 
+    function setNodeWithoutHTTP(version) {
+      const nodes = { 'node-without-http': { version, ip: 'ip' } };
+      const client = server.plugins.elasticsearch.client;
+      client.nodes.info = sinon.stub().returns(Promise.resolve({ nodes: nodes }));
+    }
+
     it('returns true with single a node that matches', async () => {
       setNodes('5.1.0');
       const result = await checkEsVersion(server, KIBANA_VERSION);
@@ -99,6 +105,24 @@ describe('plugins/elasticsearch', () => {
       expect(server.log.getCall(1).args[0]).to.contain('warning');
     });
 
+    it('warns if a node is off by a patch version and without http publish address', async () => {
+      setNodeWithoutHTTP('5.1.1');
+      await checkEsVersion(server, KIBANA_VERSION);
+      sinon.assert.callCount(server.log, 2);
+      expect(server.log.getCall(0).args[0]).to.contain('debug');
+      expect(server.log.getCall(1).args[0]).to.contain('warning');
+    });
+
+    it('errors if a node incompatible and without http publish address', async () => {
+      setNodeWithoutHTTP('6.1.1');
+      try {
+        await checkEsVersion(server, KIBANA_VERSION);
+      } catch (e) {
+        expect(e.message).to.contain('incompatible nodes');
+        expect(e).to.be.a(Error);
+      }
+    });
+
     it('only warns once per node list', async () => {
       setNodes('5.1.1');
 
diff --git a/src/core_plugins/elasticsearch/lib/__tests__/get_basic_auth_realm.js b/src/core_plugins/elasticsearch/lib/__tests__/get_basic_auth_realm.js
deleted file mode 100644
index 7dc84e75730c8..0000000000000
--- a/src/core_plugins/elasticsearch/lib/__tests__/get_basic_auth_realm.js
+++ /dev/null
@@ -1,27 +0,0 @@
-import getBasicAuthRealm from '../get_basic_auth_realm';
-import expect from 'expect.js';
-const exception = '[security_exception] missing authentication token for REST request [/logstash-*/_search],' +
-                  ' with: {"header":{"WWW-Authenticate":"Basic realm=\\"shield\\""}}';
-
-
-describe('plugins/elasticsearch', function () {
-  describe('lib/get_basic_auth_realm', function () {
-
-    it('should return null if passed something other than a string', function () {
-      expect(getBasicAuthRealm({})).to.be(null);
-      expect(getBasicAuthRealm(500)).to.be(null);
-      expect(getBasicAuthRealm([exception])).to.be(null);
-    });
-
-    // TODO: This should be updated to match header strings when the client supports that
-    it('should return the realm when passed an elasticsearch security exception', function () {
-      expect(getBasicAuthRealm(exception)).to.be('shield');
-    });
-
-    it('should return null when no basic realm information is found', function () {
-      expect(getBasicAuthRealm('Basically nothing="the universe"')).to.be(null);
-    });
-
-  });
-});
-
diff --git a/src/core_plugins/elasticsearch/lib/call_with_request.js b/src/core_plugins/elasticsearch/lib/call_with_request.js
index 870b856de5fce..ed53ee36ca372 100644
--- a/src/core_plugins/elasticsearch/lib/call_with_request.js
+++ b/src/core_plugins/elasticsearch/lib/call_with_request.js
@@ -1,14 +1,14 @@
 import _ from 'lodash';
 import Promise from 'bluebird';
 import Boom from 'boom';
-import getBasicAuthRealm from './get_basic_auth_realm';
 import toPath from 'lodash/internal/toPath';
 import filterHeaders from './filter_headers';
 
 module.exports = (server, client) => {
-  return (req, endpoint, params = {}) => {
+  return (req, endpoint, clientParams = {}, options = {}) => {
+    const wrap401Errors = options.wrap401Errors !== false;
     const filteredHeaders = filterHeaders(req.headers, server.config().get('elasticsearch.requestHeadersWhitelist'));
-    _.set(params, 'headers', filteredHeaders);
+    _.set(clientParams, 'headers', filteredHeaders);
     const path = toPath(endpoint);
     const api = _.get(client, path);
     let apiContext = _.get(client, path.slice(0, -1));
@@ -16,16 +16,16 @@ module.exports = (server, client) => {
       apiContext = client;
     }
     if (!api) throw new Error(`callWithRequest called with an invalid endpoint: ${endpoint}`);
-    return api.call(apiContext, params)
+    return api.call(apiContext, clientParams)
       .catch((err) => {
-        if (err.status === 401) {
-          // TODO: The err.message is temporary until we have support for getting headers in the client.
-          // Once we have that, we should be able to pass the contents of the WWW-Authenticate head to getRealm
-          const realm = getBasicAuthRealm(err.message) || 'Authorization Required';
-          const options = { realm: realm };
-          return Promise.reject(Boom.unauthorized('Unauthorized', 'Basic', options));
+        if (!wrap401Errors || err.statusCode !== 401) {
+          return Promise.reject(err);
         }
-        return Promise.reject(err);
+
+        const boomError = Boom.wrap(err, err.statusCode);
+        const wwwAuthHeader = _.get(err, 'body.error.header[WWW-Authenticate]');
+        boomError.output.headers['WWW-Authenticate'] = wwwAuthHeader || 'Basic realm="Authorization Required"';
+        throw boomError;
       });
   };
 };
diff --git a/src/core_plugins/elasticsearch/lib/check_es_version.js b/src/core_plugins/elasticsearch/lib/check_es_version.js
index b9eddd0e0f249..a6cc89978ac9b 100644
--- a/src/core_plugins/elasticsearch/lib/check_es_version.js
+++ b/src/core_plugins/elasticsearch/lib/check_es_version.js
@@ -44,7 +44,8 @@ module.exports = function checkEsVersion(server, kibanaVersion) {
 
     function getHumanizedNodeNames(nodes) {
       return nodes.map(node => {
-        return 'v' + node.version + ' @ ' + node.http.publish_address + ' (' + node.ip + ')';
+        const publishAddress =  _.get(node, 'http.publish_address') ? (_.get(node, 'http.publish_address') + ' ') : '';
+        return 'v' + node.version + ' @ ' + publishAddress + '(' + node.ip + ')';
       });
     }
 
@@ -52,7 +53,7 @@ module.exports = function checkEsVersion(server, kibanaVersion) {
       const simplifiedNodes = warningNodes.map(node => ({
         version: node.version,
         http: {
-          publish_address: node.http.publish_address,
+          publish_address: _.get(node, 'http.publish_address')
         },
         ip: node.ip,
       }));
@@ -78,7 +79,7 @@ module.exports = function checkEsVersion(server, kibanaVersion) {
       throw new Error(
         `This version of Kibana requires Elasticsearch v` +
         `${kibanaVersion} on all nodes. I found ` +
-        `the following incompatible nodes in your cluster: ${incompatibleNodeNames.join(',')}`
+        `the following incompatible nodes in your cluster: ${incompatibleNodeNames.join(', ')}`
       );
     }
 
diff --git a/src/core_plugins/elasticsearch/lib/get_basic_auth_realm.js b/src/core_plugins/elasticsearch/lib/get_basic_auth_realm.js
deleted file mode 100644
index 9a9c183def983..0000000000000
--- a/src/core_plugins/elasticsearch/lib/get_basic_auth_realm.js
+++ /dev/null
@@ -1,7 +0,0 @@
-export default function getBasicAuthRealm(message) {
-  if (!message || typeof message !== 'string') return null;
-
-  const parts = message.match(/Basic\ realm=\\"(.*)\\"/);
-  if (parts && parts.length === 2) return parts[1];
-  else return null;
-};
\ No newline at end of file
diff --git a/src/core_plugins/kbn_vislib_vis_types/public/area.js b/src/core_plugins/kbn_vislib_vis_types/public/area.js
index 9e8e80d5f89cd..cf33aaef09a04 100644
--- a/src/core_plugins/kbn_vislib_vis_types/public/area.js
+++ b/src/core_plugins/kbn_vislib_vis_types/public/area.js
@@ -47,6 +47,7 @@ export default function HistogramVisType(Private) {
       modes: ['stacked', 'overlap', 'percentage', 'wiggle', 'silhouette'],
       editor: areaTemplate
     },
+    implementsRenderComplete: true,
     schemas: new Schemas([
       {
         group: 'metrics',
diff --git a/src/core_plugins/kbn_vislib_vis_types/public/histogram.js b/src/core_plugins/kbn_vislib_vis_types/public/histogram.js
index 1b2d803ac644b..3b3db63fddcdc 100644
--- a/src/core_plugins/kbn_vislib_vis_types/public/histogram.js
+++ b/src/core_plugins/kbn_vislib_vis_types/public/histogram.js
@@ -43,6 +43,7 @@ export default function HistogramVisType(Private) {
       modes: ['stacked', 'percentage', 'grouped'],
       editor: histogramTemplate
     },
+    implementsRenderComplete: true,
     schemas: new Schemas([
       {
         group: 'metrics',
diff --git a/src/core_plugins/kbn_vislib_vis_types/public/line.js b/src/core_plugins/kbn_vislib_vis_types/public/line.js
index a8b4eedff6535..c061d6183237d 100644
--- a/src/core_plugins/kbn_vislib_vis_types/public/line.js
+++ b/src/core_plugins/kbn_vislib_vis_types/public/line.js
@@ -46,6 +46,7 @@ export default function HistogramVisType(Private) {
       scales: ['linear', 'log', 'square root'],
       editor: lineTemplate
     },
+    implementsRenderComplete: true,
     schemas: new Schemas([
       {
         group: 'metrics',
diff --git a/src/core_plugins/kbn_vislib_vis_types/public/pie.js b/src/core_plugins/kbn_vislib_vis_types/public/pie.js
index 64b4b4688156f..9a66fd9924ccb 100644
--- a/src/core_plugins/kbn_vislib_vis_types/public/pie.js
+++ b/src/core_plugins/kbn_vislib_vis_types/public/pie.js
@@ -37,6 +37,7 @@ export default function HistogramVisType(Private) {
     },
     responseConverter: false,
     hierarchicalData: true,
+    implementsRenderComplete: true,
     schemas: new Schemas([
       {
         group: 'metrics',
diff --git a/src/core_plugins/kbn_vislib_vis_types/public/tile_map.js b/src/core_plugins/kbn_vislib_vis_types/public/tile_map.js
index 875c079a2558e..1a79dfd35ac19 100644
--- a/src/core_plugins/kbn_vislib_vis_types/public/tile_map.js
+++ b/src/core_plugins/kbn_vislib_vis_types/public/tile_map.js
@@ -81,6 +81,7 @@ export default function TileMapVisType(Private, getAppState, courier, config) {
       }
     },
     responseConverter: geoJsonConverter,
+    implementsRenderComplete: true,
     schemas: new Schemas([
       {
         group: 'metrics',
diff --git a/src/core_plugins/kibana/public/dashboard/components/panel/panel.html b/src/core_plugins/kibana/public/dashboard/components/panel/panel.html
index 6665034471980..874a62b75522a 100644
--- a/src/core_plugins/kibana/public/dashboard/components/panel/panel.html
+++ b/src/core_plugins/kibana/public/dashboard/components/panel/panel.html
@@ -28,13 +28,16 @@
     search-source="savedObj.searchSource"
     show-spy-panel="chrome.getVisible()"
     ui-state="uiState"
+    render-counter
     class="panel-content">
   </visualize>
 
-  <doc-table ng-switch-when="search"
+  <doc-table
+    ng-switch-when="search"
     search-source="savedObj.searchSource"
     sorting="panel.sort"
     columns="panel.columns"
+    render-counter
     class="panel-content"
     filter="filter">
   </doc-table>
diff --git a/src/core_plugins/kibana/public/discover/index.html b/src/core_plugins/kibana/public/discover/index.html
index 1a60d56b6b641..0f2faa466bc67 100644
--- a/src/core_plugins/kibana/public/discover/index.html
+++ b/src/core_plugins/kibana/public/discover/index.html
@@ -125,7 +125,8 @@ <h2>Searching</h2>
                 sorting="state.sort"
                 columns="state.columns"
                 infinite-scroll="true"
-                filter="filterQuery">
+                filter="filterQuery"
+                render-counter>
               </doc-table>
 
               <div ng-if="rows.length == opts.sampleSize" class="discover-table-footer">
diff --git a/src/core_plugins/kibana/public/visualize/editor/editor.html b/src/core_plugins/kibana/public/visualize/editor/editor.html
index f0547cbe8e87a..44d62bb5a3fc2 100644
--- a/src/core_plugins/kibana/public/visualize/editor/editor.html
+++ b/src/core_plugins/kibana/public/visualize/editor/editor.html
@@ -80,6 +80,7 @@
     <div class="vis-editor-canvas" ng-class="{ embedded: !chrome.getVisible() }">
       <visualize
         vis="vis"
+        render-counter
         ui-state="uiState"
         show-spy-panel="chrome.getVisible()"
         editable-vis="editableVis"
diff --git a/src/core_plugins/kibana/server/routes/api/settings/register_delete.js b/src/core_plugins/kibana/server/routes/api/settings/register_delete.js
index 46c675c9e9650..ea68620298d3d 100644
--- a/src/core_plugins/kibana/server/routes/api/settings/register_delete.js
+++ b/src/core_plugins/kibana/server/routes/api/settings/register_delete.js
@@ -8,12 +8,12 @@ export default function registerDelete(server) {
       const { key } = req.params;
       const uiSettings = server.uiSettings();
       uiSettings
-        .remove(key)
+        .remove(req, key)
         .then(() => uiSettings
-          .getUserProvided()
+          .getUserProvided(req)
           .then(settings => reply({ settings }).type('application/json'))
         )
-        .catch(reason => reply(Boom.wrap(reason)));
+        .catch(err => reply(Boom.wrap(err, err.statusCode)));
     }
   });
 }
diff --git a/src/core_plugins/kibana/server/routes/api/settings/register_get.js b/src/core_plugins/kibana/server/routes/api/settings/register_get.js
index 217dc3936430e..85fc8c9ca5f27 100644
--- a/src/core_plugins/kibana/server/routes/api/settings/register_get.js
+++ b/src/core_plugins/kibana/server/routes/api/settings/register_get.js
@@ -7,9 +7,9 @@ export default function registerGet(server) {
     handler: function (req, reply) {
       server
         .uiSettings()
-        .getUserProvided()
+        .getUserProvided(req)
         .then(settings => reply({ settings }).type('application/json'))
-        .catch(reason => reply(Boom.wrap(reason)));
+        .catch(err => reply(Boom.wrap(err, err.statusCode)));
     }
   });
 }
diff --git a/src/core_plugins/kibana/server/routes/api/settings/register_set.js b/src/core_plugins/kibana/server/routes/api/settings/register_set.js
index 51dc364c6c2b9..8d572bbd1ab25 100644
--- a/src/core_plugins/kibana/server/routes/api/settings/register_set.js
+++ b/src/core_plugins/kibana/server/routes/api/settings/register_set.js
@@ -9,12 +9,12 @@ export default function registerSet(server) {
       const { value } = req.payload;
       const uiSettings = server.uiSettings();
       uiSettings
-        .set(key, value)
+        .set(req, key, value)
         .then(() => uiSettings
-          .getUserProvided()
+          .getUserProvided(req)
           .then(settings => reply({ settings }).type('application/json'))
         )
-        .catch(reason => reply(Boom.wrap(reason)));
+        .catch(err => reply(Boom.wrap(err, err.statusCode)));
     }
   });
 }
diff --git a/src/core_plugins/kibana/server/routes/api/settings/register_set_many.js b/src/core_plugins/kibana/server/routes/api/settings/register_set_many.js
index 7ab2c035de76f..1fe4abe9a9966 100644
--- a/src/core_plugins/kibana/server/routes/api/settings/register_set_many.js
+++ b/src/core_plugins/kibana/server/routes/api/settings/register_set_many.js
@@ -9,12 +9,12 @@ export default function registerSet(server) {
       const { changes } = req.payload;
       const uiSettings = server.uiSettings();
       uiSettings
-        .setMany(changes)
+        .setMany(req, changes)
         .then(() => uiSettings
-          .getUserProvided()
+          .getUserProvided(req)
           .then(settings => reply({ settings }).type('application/json'))
         )
-        .catch(reason => reply(Boom.wrap(reason)));
+        .catch(err => reply(Boom.wrap(err, err.statusCode)));
     }
   });
 }
diff --git a/src/core_plugins/markdown_vis/public/__tests__/markdown_vis_controller.js b/src/core_plugins/markdown_vis/public/__tests__/markdown_vis_controller.js
index b85bf484f99f7..f9dc317de5f2b 100644
--- a/src/core_plugins/markdown_vis/public/__tests__/markdown_vis_controller.js
+++ b/src/core_plugins/markdown_vis/public/__tests__/markdown_vis_controller.js
@@ -1,24 +1,24 @@
 import ngMock from 'ng_mock';
 import expect from 'expect.js';
+import $ from 'jquery';
 
 describe('markdown vis controller', function () {
   let $scope;
-  let $el;
 
   beforeEach(ngMock.module('kibana/markdown_vis'));
   beforeEach(ngMock.inject(function ($rootScope, $controller) {
     $scope = $rootScope.$new();
-    $scope.vis = {
-      emit: function () {}
-    };
-    $controller('KbnMarkdownVisController', {$scope: $scope});
+    const $element = $('<div>');
+    $controller('KbnMarkdownVisController', { $scope, $element });
     $scope.$digest();
   }));
 
   it('should set html from markdown params', function () {
     expect($scope).to.not.have.property('html');
-    $scope.vis.params = {
-      markdown: 'This is a test of the [markdown](http://daringfireball.net/projects/markdown) vis.'
+    $scope.vis = {
+      params: {
+        markdown: 'This is a test of the [markdown](http://daringfireball.net/projects/markdown) vis.'
+      }
     };
     $scope.$digest();
 
diff --git a/src/core_plugins/markdown_vis/public/markdown_vis_controller.js b/src/core_plugins/markdown_vis/public/markdown_vis_controller.js
index 11e44ca55727b..6913833640540 100644
--- a/src/core_plugins/markdown_vis/public/markdown_vis_controller.js
+++ b/src/core_plugins/markdown_vis/public/markdown_vis_controller.js
@@ -9,11 +9,11 @@ marked.setOptions({
 
 
 const module = uiModules.get('kibana/markdown_vis', ['kibana', 'ngSanitize']);
-module.controller('KbnMarkdownVisController', function ($scope) {
+module.controller('KbnMarkdownVisController', function ($scope, $element) {
   $scope.$watch('vis.params.markdown', function (html) {
     if (html) {
       $scope.html = marked(html);
     }
-    $scope.vis.emit('renderComplete');
+    $element.trigger('renderComplete');
   });
 });
diff --git a/src/core_plugins/metric_vis/public/__tests__/metric_vis_controller.js b/src/core_plugins/metric_vis/public/__tests__/metric_vis_controller.js
index a745d90c7f841..af11e615e94a8 100644
--- a/src/core_plugins/metric_vis/public/__tests__/metric_vis_controller.js
+++ b/src/core_plugins/metric_vis/public/__tests__/metric_vis_controller.js
@@ -1,5 +1,6 @@
 import ngMock from 'ng_mock';
 import expect from 'expect.js';
+import $ from 'jquery';
 
 describe('metric vis', function () {
   let $scope;
@@ -11,7 +12,8 @@ describe('metric vis', function () {
   beforeEach(ngMock.module('kibana/metric_vis'));
   beforeEach(ngMock.inject(function ($rootScope, $controller) {
     $scope = $rootScope.$new();
-    $controller('KbnMetricVisController', {$scope: $scope});
+    const $element = $('<div>');
+    $controller('KbnMetricVisController', { $scope, $element });
     $scope.$digest();
   }));
 
diff --git a/src/core_plugins/metric_vis/public/metric_vis_controller.js b/src/core_plugins/metric_vis/public/metric_vis_controller.js
index 2597b49e3e0c5..c9efb01d417a9 100644
--- a/src/core_plugins/metric_vis/public/metric_vis_controller.js
+++ b/src/core_plugins/metric_vis/public/metric_vis_controller.js
@@ -5,7 +5,7 @@ import uiModules from 'ui/modules';
 // didn't already
 const module = uiModules.get('kibana/metric_vis', ['kibana']);
 
-module.controller('KbnMetricVisController', function ($scope, Private) {
+module.controller('KbnMetricVisController', function ($scope, $element, Private) {
   const tabifyAggResponse = Private(AggResponseTabifyTabifyProvider);
 
   const metrics = $scope.metrics = [];
@@ -34,7 +34,7 @@ module.controller('KbnMetricVisController', function ($scope, Private) {
     if (resp) {
       metrics.length = 0;
       $scope.processTableGroups(tabifyAggResponse($scope.vis, resp));
-      $scope.vis.emit('renderComplete');
+      $element.trigger('renderComplete');
     }
   });
 });
diff --git a/src/core_plugins/table_vis/public/table_vis_controller.js b/src/core_plugins/table_vis/public/table_vis_controller.js
index b87a915910a6a..c32839a8347af 100644
--- a/src/core_plugins/table_vis/public/table_vis_controller.js
+++ b/src/core_plugins/table_vis/public/table_vis_controller.js
@@ -8,7 +8,7 @@ const module = uiModules.get('kibana/table_vis', ['kibana']);
 
 // add a controller to tha module, which will transform the esResponse into a
 // tabular format that we can pass to the table directive
-module.controller('KbnTableVisController', function ($scope, Private) {
+module.controller('KbnTableVisController', function ($scope, $element, Private) {
   const tabifyAggResponse = Private(AggResponseTabifyTabifyProvider);
 
   var uiStateSort = ($scope.uiState) ? $scope.uiState.get('vis.params.sort') : {};
@@ -44,7 +44,7 @@ module.controller('KbnTableVisController', function ($scope, Private) {
         return table.rows.length > 0;
       });
 
-      $scope.vis.emit('renderComplete');
+      $element.trigger('renderComplete');
     }
 
     $scope.hasSomeRows = hasSomeRows;
diff --git a/src/core_plugins/tagcloud/index.js b/src/core_plugins/tagcloud/index.js
new file mode 100644
index 0000000000000..fe00c2462e893
--- /dev/null
+++ b/src/core_plugins/tagcloud/index.js
@@ -0,0 +1,8 @@
+export default function (kibana) {
+
+  return new kibana.Plugin({
+    uiExports: {
+      visTypes: ['plugins/tagcloud/tag_cloud_vis']
+    }
+  });
+};
diff --git a/src/core_plugins/tagcloud/package.json b/src/core_plugins/tagcloud/package.json
new file mode 100644
index 0000000000000..4200ef264fece
--- /dev/null
+++ b/src/core_plugins/tagcloud/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "tagcloud",
+  "version": "kibana"
+}
diff --git a/src/core_plugins/tagcloud/public/__tests__/tag_cloud.js b/src/core_plugins/tagcloud/public/__tests__/tag_cloud.js
new file mode 100644
index 0000000000000..1b78b02b9aff3
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/__tests__/tag_cloud.js
@@ -0,0 +1,181 @@
+import expect from 'expect.js';
+import _ from 'lodash';
+import TagCloud from 'plugins/tagcloud/tag_cloud';
+
+describe('tag cloud', function () {
+
+  let domNode;
+
+  beforeEach(function () {
+    domNode = document.createElement('div');
+    domNode.style.top = '0';
+    domNode.style.left = '0';
+    domNode.style.width = '512px';
+    domNode.style.height = '512px';
+    domNode.style.position = 'fixed';
+    domNode.style['pointer-events'] = 'none';
+    document.body.appendChild(domNode);
+  });
+
+  afterEach(function () {
+    document.body.removeChild(domNode);
+  });
+
+
+  const baseTestConfig = {
+    data: [
+      {text: 'foo', size: 1},
+      {text: 'bar', size: 5},
+      {text: 'foobar', size: 9},
+    ],
+    options: {
+      orientation: 'single',
+      scale: 'linear',
+      minFontSize: 10,
+      maxFontSize: 36
+    },
+    expected: [
+      {
+        text: 'foo',
+        fontSize: '10px'
+      },
+      {
+        text: 'bar',
+        fontSize: '23px'
+      },
+      {
+        text: 'foobar',
+        fontSize: '36px'
+      }
+    ]
+  };
+
+  const singleLayout = _.cloneDeep(baseTestConfig);
+  const rightAngleLayout = _.cloneDeep(baseTestConfig);
+  rightAngleLayout.options.orientation = 'right angled';
+  const multiLayout = _.cloneDeep(baseTestConfig);
+  multiLayout.options.orientation = 'multiple';
+  const logScale = _.cloneDeep(baseTestConfig);
+  logScale.options.scale = 'log';
+  logScale.expected[1].fontSize = '31px';
+  const sqrtScale = _.cloneDeep(baseTestConfig);
+  sqrtScale.options.scale = 'square root';
+  sqrtScale.expected[1].fontSize = '27px';
+  const biggerFont = _.cloneDeep(baseTestConfig);
+  biggerFont.options.minFontSize = 36;
+  biggerFont.options.maxFontSize = 72;
+  biggerFont.expected[0].fontSize = '36px';
+  biggerFont.expected[1].fontSize = '54px';
+  biggerFont.expected[2].fontSize = '72px';
+
+  [
+    singleLayout,
+    rightAngleLayout,
+    multiLayout,
+    logScale,
+    sqrtScale,
+    biggerFont
+  ].forEach((test, index) => {
+
+    it(`should position elements correctly: ${index}`, done => {
+      const tagCloud = new TagCloud(domNode);
+      tagCloud.setData(test.data);
+      tagCloud.setOptions(test.options);
+      tagCloud.on('renderComplete', function onRender() {
+        tagCloud.removeListener('renderComplete', onRender);
+        const textElements = domNode.querySelectorAll('text');
+        verifyTagProperties(test.expected, textElements);
+        expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.COMPLETE);
+        done();
+      });
+    });
+  });
+
+  it(`should not put elements in view when container to small`, function (done) {
+
+    domNode.style.width = '1px';
+    domNode.style.height = '1px';
+
+    const tagCloud = new TagCloud(domNode);
+    tagCloud.setData(baseTestConfig.data);
+    tagCloud.setOptions(baseTestConfig.options);
+    tagCloud.on('renderComplete', function onRender() {
+      tagCloud.removeListener('renderComplete', onRender);
+      expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.INCOMPLETE);
+      const textElements = domNode.querySelectorAll('text');
+      for (let i = 0; i < textElements; i++) {
+        const bbox = textElements[i].getBoundingClientRect();
+        verifyBbox(bbox, false);
+      }
+      done();
+    });
+  });
+
+
+  it(`tags should fit after making container bigger`, function (done) {
+
+    domNode.style.width = '1px';
+    domNode.style.height = '1px';
+
+    const tagCloud = new TagCloud(domNode);
+    tagCloud.setData(baseTestConfig.data);
+    tagCloud.setOptions(baseTestConfig.options);
+    tagCloud.on('renderComplete', function onRender() {
+      tagCloud.removeListener('renderComplete', onRender);
+      expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.INCOMPLETE);
+
+      domNode.style.width = '512px';
+      domNode.style.height = '512px';
+      tagCloud.on('renderComplete', _ => {
+        expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.COMPLETE);
+        done();
+      });
+      tagCloud.resize();
+
+    });
+  });
+
+  it(`tags should no longer fit after making container smaller`, function (done) {
+
+    const tagCloud = new TagCloud(domNode);
+    tagCloud.setData(baseTestConfig.data);
+    tagCloud.setOptions(baseTestConfig.options);
+    tagCloud.on('renderComplete', function onRender() {
+      tagCloud.removeListener('renderComplete', onRender);
+      expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.COMPLETE);
+
+      domNode.style.width = '1px';
+      domNode.style.height = '1px';
+      tagCloud.on('renderComplete', _ => {
+        expect(tagCloud.getStatus()).to.equal(TagCloud.STATUS.INCOMPLETE);
+        done();
+      });
+      tagCloud.resize();
+
+    });
+
+  });
+
+  function verifyTagProperties(expectedValues, actualElements) {
+    expect(actualElements.length).to.equal(expectedValues.length);
+    expectedValues.forEach((test, index) => {
+      expect(actualElements[index].style.fontSize).to.equal(test.fontSize);
+      expect(actualElements[index].innerHTML).to.equal(test.text);
+      isInsideContainer(actualElements[index]);
+    });
+  }
+
+  function isInsideContainer(actualElement) {
+    const bbox = actualElement.getBoundingClientRect();
+    verifyBbox(bbox, true);
+  }
+
+  function verifyBbox(bbox, shouldBeInside) {
+    expect(bbox.top >= 0 && bbox.top <= domNode.offsetHeight).to.be(shouldBeInside);
+    expect(bbox.bottom >= 0 && bbox.bottom <= domNode.offsetHeight).to.be(shouldBeInside);
+    expect(bbox.left >= 0 && bbox.left <= domNode.offsetWidth).to.be(shouldBeInside);
+    expect(bbox.right >= 0 && bbox.right <= domNode.offsetWidth).to.be(shouldBeInside);
+  }
+
+
+});
diff --git a/src/core_plugins/tagcloud/public/tag_cloud.js b/src/core_plugins/tagcloud/public/tag_cloud.js
new file mode 100644
index 0000000000000..712826f6e23f4
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud.js
@@ -0,0 +1,319 @@
+import d3 from 'd3';
+import d3TagCloud from 'd3-cloud';
+import vislibComponentsSeedColorsProvider from 'ui/vislib/components/color/seed_colors';
+import {EventEmitter} from 'events';
+
+
+const ORIENTATIONS = {
+  'single': () => 0,
+  'right angled': (tag) => {
+    return hashCode(tag.text) % 2 * 90;
+  },
+  'multiple': (tag) => {
+    const hashcode = Math.abs(hashCode(tag.text));
+    return ((hashcode % 12) * 15) - 90;//fan out 12 * 15 degrees over top-right and bottom-right quadrant (=-90 deg offset)
+  }
+};
+const D3_SCALING_FUNCTIONS = {
+  'linear': d3.scale.linear(),
+  'log': d3.scale.log(),
+  'square root': d3.scale.sqrt()
+};
+
+
+class TagCloud extends EventEmitter {
+
+  constructor(domNode) {
+
+    super();
+
+    this._element = domNode;
+    this._d3SvgContainer = d3.select(this._element).append('svg');
+    this._svgGroup = this._d3SvgContainer.append('g');
+    this._size = [1, 1];
+    this.resize();
+
+    this._fontFamily = 'Impact';
+    this._fontStyle = 'normal';
+    this._fontWeight = 'normal';
+    this._orientation = 'single';
+    this._minFontSize = 10;
+    this._maxFontSize = 36;
+    this._textScale = 'linear';
+    this._spiral = 'archimedean';//layout shape
+    this._timeInterval = 1000;//time allowed for layout algorithm
+    this._padding = 5;
+
+  }
+
+
+  setOptions(options) {
+    if (JSON.stringify(options) === this._optionsAsString) {
+      return;
+    }
+
+    this._optionsAsString = JSON.stringify(options);
+    this._orientation = options.orientation;
+    this._minFontSize = Math.min(options.minFontSize, options.maxFontSize);
+    this._maxFontSize = Math.max(options.minFontSize, options.maxFontSize);
+    this._textScale = options.scale;
+    this._invalidate(false);
+  }
+
+
+  resize() {
+
+    const newWidth = this._element.offsetWidth;
+    const newHeight = this._element.offsetHeight;
+
+    if (newWidth < 1 || newHeight < 1) {
+      return;
+    }
+
+    if (newWidth === this._size[0] && newHeight === this._size[1]) {
+      return;
+    }
+
+    const wasInside = this._size[0] >= this._cloudWidth && this._size[1] >= this._cloudHeight;
+    const willBeInside = this._cloudWidth <= newWidth && this._cloudHeight <= newHeight;
+
+    this._size[0] = newWidth;
+    this._size[1] = newHeight;
+
+    if (wasInside && willBeInside && this._allInViewBox) {
+      this._invalidate(true);
+    } else {
+      this._invalidate(false);
+    }
+
+  }
+
+  setData(data) {
+    this._words = data.map(toWordTag);
+    this._makeTextSizeMapper();
+    this._invalidate(false);
+  }
+
+
+  destroy() {
+    clearTimeout(this._timeoutHandle);
+    this._element.innerHTML = '';
+  }
+
+  getStatus() {
+    return this._allInViewBox ? TagCloud.STATUS.COMPLETE : TagCloud.STATUS.INCOMPLETE;
+  }
+
+  _updateContainerSize() {
+    this._d3SvgContainer.attr('width', this._size[0]);
+    this._d3SvgContainer.attr('height', this._size[1]);
+    this._svgGroup.attr('width', this._size[0]);
+    this._svgGroup.attr('height', this._size[1]);
+  }
+
+  _washWords() {
+    if (!this._words) {
+      return;
+    }
+
+    //the tagCloudLayoutGenerator clobbers the word-object with metadata about positioning.
+    //This can causes corrupt states in the layout-generator
+    //where words get collapsed to the same location and do not reposition correctly.
+    //=> we recreate an empty word object without the metadata
+    this._words = this._words.map(toWordTag);
+    this._makeTextSizeMapper();
+  }
+
+  _onLayoutEnd() {
+
+    const affineTransform = positionWord.bind(null, this._element.offsetWidth / 2, this._element.offsetHeight / 2);
+    const svgTextNodes = this._svgGroup.selectAll('text');
+    const stage = svgTextNodes.data(this._words, getText);
+
+    const enterSelection = stage.enter();
+    const enteringTags = enterSelection.append('text');
+    enteringTags.style('font-size', getSizeInPixels);
+    enteringTags.style('font-style', this._fontStyle);
+    enteringTags.style('font-weight', () => this._fontWeight);
+    enteringTags.style('font-family', () => this._fontFamily);
+    enteringTags.style('fill', getFill);
+    enteringTags.attr('text-anchor', () => 'middle');
+    enteringTags.attr('transform', affineTransform);
+    enteringTags.text(getText);
+
+    const self = this;
+    enteringTags.on({
+      click: function (event) {
+        self.emit('select', event.text);
+      },
+      mouseover: function (d) {
+        d3.select(this).style('cursor', 'pointer');
+      },
+      mouseout: function (d) {
+        d3.select(this).style('cursor', 'default');
+      }
+    });
+
+    const movingTags = stage.transition();
+    movingTags.duration(600);
+    movingTags.style('font-size', getSizeInPixels);
+    movingTags.style('font-style', this._fontStyle);
+    movingTags.style('font-weight', () => this._fontWeight);
+    movingTags.style('font-family', () => this._fontFamily);
+    movingTags.attr('transform', affineTransform);
+
+    const exitingTags = stage.exit();
+    const exitTransition = exitingTags.transition();
+    exitTransition.duration(200);
+    exitingTags.style('fill-opacity', 1e-6);
+    exitingTags.attr('font-size', 1);
+    exitingTags.remove();
+
+    let exits = 0;
+    let moves = 0;
+    const resolveWhenDone = () => {
+      if (exits === 0 && moves === 0) {
+        const cloudBBox = this._svgGroup[0][0].getBBox();
+        this._cloudWidth = cloudBBox.width;
+        this._cloudHeight = cloudBBox.height;
+        this._allInViewBox = cloudBBox.x >= 0 && cloudBBox.y >= 0 &&
+          cloudBBox.x + cloudBBox.width <= this._element.offsetWidth &&
+          cloudBBox.y + cloudBBox.height <= this._element.offsetHeight;
+
+        this._dirtyPromise = null;
+        this._resolve(true);
+        this.emit('renderComplete');
+      }
+    };
+    exitTransition.each(_ => exits++);
+    exitTransition.each('end', () => {
+      exits--;
+      resolveWhenDone();
+    });
+    movingTags.each(_ => moves++);
+    movingTags.each('end', () => {
+      moves--;
+      resolveWhenDone();
+    });
+
+  };
+
+
+  _makeTextSizeMapper() {
+    this._mapSizeToFontSize = D3_SCALING_FUNCTIONS[this._textScale];
+    if (this._words.length === 1) {
+      this._mapSizeToFontSize.range([this._maxFontSize, this._maxFontSize]);
+    } else {
+      this._mapSizeToFontSize.range([this._minFontSize, this._maxFontSize]);
+    }
+
+    if (this._words) {
+      this._mapSizeToFontSize.domain(d3.extent(this._words, getSize));
+    }
+  }
+
+  _invalidate(keepLayout) {
+
+
+    if (!this._words) {
+      return;
+    }
+
+    if (!this._dirtyPromise) {
+      this._dirtyPromise = new Promise((resolve, reject) => {
+        this._resolve = resolve;
+      });
+    }
+
+    clearTimeout(this._timeoutHandle);
+    this._timeoutHandle = requestAnimationFrame(() => {
+      this._timeoutHandle = null;
+      this._updateContainerSize();
+      if (keepLayout) {
+        this._onLayoutEnd();
+      } else {
+        this._washWords();
+        this._updateLayout();
+      }
+    });
+  }
+
+  _updateLayout() {
+
+    const tagCloudLayoutGenerator = d3TagCloud();
+    tagCloudLayoutGenerator.size(this._size);
+    tagCloudLayoutGenerator.padding(this._padding);
+    tagCloudLayoutGenerator.rotate(ORIENTATIONS[this._orientation]);
+    tagCloudLayoutGenerator.font(this._fontFamily);
+    tagCloudLayoutGenerator.fontStyle(this._fontStyle);
+    tagCloudLayoutGenerator.fontWeight(this._fontWeight);
+    tagCloudLayoutGenerator.fontSize(tag => this._mapSizeToFontSize(tag.size));
+    tagCloudLayoutGenerator.random(seed);
+    tagCloudLayoutGenerator.spiral(this._spiral);
+    tagCloudLayoutGenerator.words(this._words);
+    tagCloudLayoutGenerator.text(getText);
+    tagCloudLayoutGenerator.timeInterval(this._timeInterval);
+    tagCloudLayoutGenerator.on('end', this._onLayoutEnd.bind(this));
+    tagCloudLayoutGenerator.start();
+
+  }
+
+}
+
+TagCloud.STATUS = {COMPLETE: 0, INCOMPLETE: 1};
+
+function seed() {
+  return 0.5;//constant random seed to ensure constant layouts for identical data
+}
+
+function toWordTag(word) {
+  return {size: word.size, text: word.text};
+}
+
+
+function getText(word) {
+  return word.text;
+}
+
+function positionWord(xTranslate, yTranslate, word) {
+
+  if (isNaN(word.x) || isNaN(word.y) || isNaN(word.rotate)) {
+    return `translate(${xTranslate * 3}, ${yTranslate * 3})rotate(0)`;
+  }
+
+  return `translate(${word.x + xTranslate}, ${word.y + yTranslate})rotate(${word.rotate})`;
+}
+
+function getSize(tag) {
+  return tag.size;
+}
+
+function getSizeInPixels(tag) {
+  return `${tag.size}px`;
+}
+
+const colorScale = d3.scale.ordinal().range(vislibComponentsSeedColorsProvider());
+function getFill(tag) {
+  return colorScale(tag.text);
+}
+
+/**
+ * Hash a string to a number. Ensures there is no random element in positioning strings
+ * Retrieved from http://stackoverflow.com/questions/26057572/string-to-unique-hash-in-javascript-jquery
+ * @param string
+ */
+function hashCode(string) {
+  string = JSON.stringify(string);
+  let hash = 0;
+  if (string.length === 0) {
+    return hash;
+  }
+  for (let i = 0; i < string.length; i++) {
+    let char = string.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return hash;
+}
+
+export default TagCloud;
diff --git a/src/core_plugins/tagcloud/public/tag_cloud.less b/src/core_plugins/tagcloud/public/tag_cloud.less
new file mode 100644
index 0000000000000..c17a378d573c6
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud.less
@@ -0,0 +1,47 @@
+.tagcloud-vis {
+  position: relative;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+}
+
+.tagcloud-notifications {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  text-align: center;
+  color: inherit;
+  font: inherit;
+}
+
+.tagcloud-incomplete-message {
+  display: none;
+}
+
+.tagcloud-truncated-message {
+  display: none;
+}
+
+.tagcloud-custom-label {
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  width: 100%;
+  text-align: center;
+  color: inherit;
+  font-weight: bold;
+}
+
+.tag-cloud-fontsize-slider {
+  margin-top: 38px;
+  margin-bottom: 36px;
+  margin-left: 12px;
+  margin-right: 24px;
+}
+
+.tag-cloud-fontsize-slider .noUi-connect {
+  background: #e4e4e4;
+}
diff --git a/src/core_plugins/tagcloud/public/tag_cloud_controller.html b/src/core_plugins/tagcloud/public/tag_cloud_controller.html
new file mode 100644
index 0000000000000..bb667aad52883
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud_controller.html
@@ -0,0 +1,7 @@
+<div ng-controller="KbnTagCloudController" class="tagcloud-vis">
+  <div ng-show="vis.params.hideLabel" class="tagcloud-custom-label"></div>
+  <div class="tagcloud-notifications">
+    <div class="tagcloud-truncated-message">The number of tags has been truncated to avoid long draw times.</div>
+    <div class="tagcloud-incomplete-message">The container is too small to display the entire cloud. Tags may appear cropped or be ommitted.</div>
+  </div>
+</div>
diff --git a/src/core_plugins/tagcloud/public/tag_cloud_controller.js b/src/core_plugins/tagcloud/public/tag_cloud_controller.js
new file mode 100644
index 0000000000000..c745831b68f12
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud_controller.js
@@ -0,0 +1,100 @@
+import _ from 'lodash';
+import uiModules from 'ui/modules';
+import TagCloud from 'plugins/tagcloud/tag_cloud';
+import AggConfigResult from 'ui/vis/agg_config_result';
+import FilterBarFilterBarClickHandlerProvider from 'ui/filter_bar/filter_bar_click_handler';
+
+const module = uiModules.get('kibana/tagcloud', ['kibana']);
+module.controller('KbnTagCloudController', function ($scope, $element, Private, getAppState) {
+
+  const containerNode = $element[0];
+  const filterBarClickHandler = Private(FilterBarFilterBarClickHandlerProvider);
+  const maxTagCount = 200;
+  let truncated = false;
+
+  const tagCloud = new TagCloud(containerNode);
+  tagCloud.on('select', (event) => {
+    const appState = getAppState();
+    const clickHandler = filterBarClickHandler(appState);
+    const aggs = $scope.vis.aggs.getResponseAggs();
+    const aggConfigResult = new AggConfigResult(aggs[0], false, event, event);
+    clickHandler({point: {aggConfigResult: aggConfigResult}});
+  });
+  tagCloud.on('renderComplete', () => {
+
+    const bucketName = containerNode.querySelector('.tagcloud-custom-label');
+    bucketName.innerHTML = `${$scope.vis.aggs[0].makeLabel()} - ${$scope.vis.aggs[1].makeLabel()}`;
+
+    const truncatedMessage = containerNode.querySelector('.tagcloud-truncated-message');
+    truncatedMessage.style.display = truncated ? 'block' : 'none';
+
+    const incompleteMessage = containerNode.querySelector('.tagcloud-incomplete-message');
+    const status = tagCloud.getStatus();
+
+    if (TagCloud.STATUS.COMPLETE === status) {
+      incompleteMessage.style.display = 'none';
+    } else if (TagCloud.STATUS.INCOMPLETE === status) {
+      incompleteMessage.style.display = 'block';
+    }
+
+    $element.trigger('renderComplete');
+  });
+
+  $scope.$watch('esResponse', async function (response) {
+
+    if (!response) {
+      return;
+    }
+
+    const tagsAggId = _.first(_.pluck($scope.vis.aggs.bySchemaName.segment, 'id'));
+    if (!tagsAggId || !response.aggregations) {
+      return;
+    }
+
+    const metricsAgg = _.first($scope.vis.aggs.bySchemaName.metric);
+    const buckets = response.aggregations[tagsAggId].buckets;
+
+    const tags = buckets.map((bucket) => {
+      return {
+        text: bucket.key,
+        size: getValue(metricsAgg, bucket)
+      };
+    });
+
+
+    if (tags.length > maxTagCount) {
+      tags.length = maxTagCount;
+      truncated = true;
+    } else {
+      truncated = false;
+    }
+
+    tagCloud.setData(tags);
+  });
+
+
+  $scope.$watch('vis.params', (options) => tagCloud.setOptions(options));
+
+  $scope.$watch(getContainerSize, _.debounce(() => {
+    tagCloud.resize();
+  }, 1000, {trailing: true}), true);
+
+
+  function getContainerSize() {
+    return {width: $element.width(), height: $element.height()};
+  }
+
+  function getValue(metricsAgg, bucket) {
+    let size = metricsAgg.getValue(bucket);
+    if (typeof size !== 'number' || isNaN(size)) {
+      try {
+        size = bucket[1].values[0].value;//lift out first value (e.g. median aggregations return as array)
+      } catch (e) {
+        size = 1;//punt
+      }
+    }
+    return size;
+  }
+
+
+});
diff --git a/src/core_plugins/tagcloud/public/tag_cloud_vis.js b/src/core_plugins/tagcloud/public/tag_cloud_vis.js
new file mode 100644
index 0000000000000..6c026ae54eb9e
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud_vis.js
@@ -0,0 +1,57 @@
+import 'plugins/tagcloud/tag_cloud.less';
+import 'plugins/tagcloud/tag_cloud_controller';
+import 'plugins/tagcloud/tag_cloud_vis_params';
+import TemplateVisTypeTemplateVisTypeProvider from 'ui/template_vis_type/template_vis_type';
+import VisSchemasProvider from 'ui/vis/schemas';
+import tagCloudTemplate from 'plugins/tagcloud/tag_cloud_controller.html';
+import visTypes from 'ui/registry/vis_types';
+
+visTypes.register(function TagCloudProvider(Private) {
+  const TemplateVisType = Private(TemplateVisTypeTemplateVisTypeProvider);
+  const Schemas = Private(VisSchemasProvider);
+
+  return new TemplateVisType({
+    name: 'tagcloud',
+    title: 'Tag cloud',
+    description: 'A tag cloud visualization is a visual representation of text data, ' +
+    'typically used to visualize free form text. Tags are usually single words. The font size of word corresponds' +
+    'with its importance.',
+    icon: 'fa-cloud',
+    template: tagCloudTemplate,
+    params: {
+      defaults: {
+        scale: 'linear',
+        orientation: 'single',
+        minFontSize: 18,
+        maxFontSize: 72
+      },
+      scales: ['linear', 'log', 'square root'],
+      orientations: ['single', 'right angled', 'multiple'],
+      editor: '<tagcloud-vis-params></tagcloud-vis-params>'
+    },
+    schemas: new Schemas([
+      {
+        group: 'metrics',
+        name: 'metric',
+        title: 'Tag Size',
+        min: 1,
+        max: 1,
+        aggFilter: ['!std_dev', '!percentiles', '!percentile_ranks'],
+        defaults: [
+          { schema: 'metric', type: 'count' }
+        ]
+      },
+      {
+        group: 'buckets',
+        name: 'segment',
+        icon: 'fa fa-cloud',
+        title: 'Tags',
+        min: 1,
+        max: 1,
+        aggFilter: ['terms']
+      }
+    ])
+  });
+});
+
+
diff --git a/src/core_plugins/tagcloud/public/tag_cloud_vis_params.html b/src/core_plugins/tagcloud/public/tag_cloud_vis_params.html
new file mode 100644
index 0000000000000..7c466480b22a5
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud_vis_params.html
@@ -0,0 +1,21 @@
+<div class="form-group">
+  <div class="form-group">
+    <label>Text Scale</label>
+    <select class="form-control" ng-model="vis.params.scale" ng-options="mode for mode in vis.type.params.scales"></select>
+  </div>
+  <div class="form-group">
+    <label>Orientations</label>
+    <select class="form-control" ng-model="vis.params.orientation" ng-options="mode for mode in vis.type.params.orientations"></select>
+  </div>
+  <div class="form-group">
+    <label>Font Size</label>
+    <div class="tag-cloud-fontsize-slider"></div>
+  </div>
+  <div>
+    <label>
+      <input type="checkbox" value="{{hideLabel}}" ng-model="vis.params.hideLabel" name="hideLabel"
+             ng-checked="vis.params.hideLabel">
+      Show Label
+    </label>
+  </div>
+</div>
diff --git a/src/core_plugins/tagcloud/public/tag_cloud_vis_params.js b/src/core_plugins/tagcloud/public/tag_cloud_vis_params.js
new file mode 100644
index 0000000000000..f6d127931d619
--- /dev/null
+++ b/src/core_plugins/tagcloud/public/tag_cloud_vis_params.js
@@ -0,0 +1,32 @@
+import uiModules from 'ui/modules';
+import tagCloudVisParamsTemplate from 'plugins/tagcloud/tag_cloud_vis_params.html';
+import noUiSlider from 'no-ui-slider';
+import 'no-ui-slider/css/nouislider.css';
+import 'no-ui-slider/css/nouislider.pips.css';
+import 'no-ui-slider/css/nouislider.tooltips.css';
+
+uiModules.get('kibana/table_vis')
+  .directive('tagcloudVisParams', function () {
+    return {
+      restrict: 'E',
+      template: tagCloudVisParamsTemplate,
+      link: function ($scope, $element) {
+        const sliderContainer = $element[0];
+        var slider = sliderContainer.querySelector('.tag-cloud-fontsize-slider');
+        noUiSlider.create(slider, {
+          start: [$scope.vis.params.minFontSize, $scope.vis.params.maxFontSize],
+          connect: true,
+          tooltips: true,
+          step: 1,
+          range: {'min': 1, 'max': 100},
+          format: {to: (value) => parseInt(value) + 'px', from: value => parseInt(value)}
+        });
+        slider.noUiSlider.on('change', function () {
+          const fontSize = slider.noUiSlider.get();
+          $scope.vis.params.minFontSize = parseInt(fontSize[0], 10);
+          $scope.vis.params.maxFontSize = parseInt(fontSize[1], 10);
+          $scope.$apply();
+        });
+      }
+    };
+  });
diff --git a/src/core_plugins/timelion/public/app.js b/src/core_plugins/timelion/public/app.js
index 2383c25178c57..481849c29b51f 100644
--- a/src/core_plugins/timelion/public/app.js
+++ b/src/core_plugins/timelion/public/app.js
@@ -46,7 +46,8 @@ require('ui/routes')
   });
 
 app.controller('timelion', function (
-  $scope, $http, timefilter, AppState, courier, $route, $routeParams, kbnUrl, Notifier, config, $timeout, Private, savedVisualizations) {
+    $scope, $http, timefilter, AppState, courier, $route, $routeParams,
+    kbnUrl, Notifier, config, $timeout, Private, savedVisualizations, safeConfirm) {
 
   // TODO: For some reason the Kibana core doesn't correctly do this for all apps.
   moment.tz.setDefault(config.get('dateFormat:tz'));
@@ -61,7 +62,6 @@ app.controller('timelion', function (
 
   var defaultExpression = '.es(*)';
   var savedSheet = $route.current.locals.savedSheet;
-  var blankSheet = [defaultExpression];
 
   $scope.topNavMenu = [{
     key: 'new',
@@ -78,6 +78,21 @@ app.controller('timelion', function (
     description: 'Save Sheet',
     template: require('plugins/timelion/partials/save_sheet.html'),
     testId: 'timelionSaveButton',
+  }, {
+    key: 'delete',
+    description: 'Delete current sheet',
+    disableButton: function () {
+      return !savedSheet.id;
+    },
+    run: function () {
+      var title = savedSheet.title;
+      safeConfirm('Are you sure you want to delete the sheet ' + title + ' ?').then(function () {
+        savedSheet.delete().then(() => {
+          notify.info('Deleted ' + title);
+          kbnUrl.change('/');
+        }).catch(notify.fatal);
+      });},
+    testId: 'timelionDeleteButton',
   }, {
     key: 'open',
     description: 'Open Sheet',
@@ -212,7 +227,6 @@ app.controller('timelion', function (
     savedSheet.timelion_columns = $scope.state.columns;
     savedSheet.timelion_rows = $scope.state.rows;
     savedSheet.save().then(function (id) {
-      //$scope.configTemplate.close('save');
       if (id) {
         notify.info('Saved sheet as "' + savedSheet.title + '"');
         if (savedSheet.id !== $routeParams.id) {
diff --git a/src/core_plugins/timelion/public/panels/timechart/schema.js b/src/core_plugins/timelion/public/panels/timechart/schema.js
index d5f1c19ced270..c80595082bafa 100644
--- a/src/core_plugins/timelion/public/panels/timechart/schema.js
+++ b/src/core_plugins/timelion/public/panels/timechart/schema.js
@@ -217,6 +217,7 @@ module.exports = function timechartFn(Private, config, $rootScope, timefilter, $
                 // This is kind of gross, it means that you can't replace a global value with a null
                 // best you can do is an empty string. Deal with it.
                 if (objVal == null) return srcVal;
+                if (srcVal == null) return objVal;
               });
             }
 
diff --git a/src/core_plugins/timelion/public/vis/timelion_vis_controller.js b/src/core_plugins/timelion/public/vis/timelion_vis_controller.js
index 8dc120c7053e6..0850b86d59561 100644
--- a/src/core_plugins/timelion/public/vis/timelion_vis_controller.js
+++ b/src/core_plugins/timelion/public/vis/timelion_vis_controller.js
@@ -6,7 +6,16 @@ define(function (require) {
 
   var _ = require('lodash');
   var module = require('ui/modules').get('kibana/timelion_vis', ['kibana']);
-  module.controller('TimelionVisController', function ($scope, Private, Notifier, $http, $rootScope, timefilter, getAppState) {
+  module.controller('TimelionVisController', function (
+    $scope,
+    $element,
+    Private,
+    Notifier,
+    $http,
+    $rootScope,
+    timefilter,
+    getAppState
+  ) {
     var queryFilter = Private(require('ui/filter_bar/query_filter'));
     var timezone = Private(require('plugins/timelion/services/timezone'))();
     var dashboardContext = Private(require('plugins/timelion/services/dashboard_context'));
@@ -61,7 +70,7 @@ define(function (require) {
 
     $scope.$on('renderComplete', event => {
       event.stopPropagation();
-      $scope.vis.emit('renderComplete');
+      $element.trigger('renderComplete');
     });
 
   });
diff --git a/src/core_plugins/timelion/server/routes/run.js b/src/core_plugins/timelion/server/routes/run.js
index 0855b2384959c..d310b20587d08 100644
--- a/src/core_plugins/timelion/server/routes/run.js
+++ b/src/core_plugins/timelion/server/routes/run.js
@@ -10,56 +10,43 @@ function replyWithError(e, reply) {
 
 
 module.exports = (server) => {
-
   server.route({
     method: ['POST', 'GET'],
     path: '/api/timelion/run',
-    handler: (request, reply) => {
+    handler: async (request, reply) => {
+      try {
+        const uiSettings = await server.uiSettings().getAll(request);
 
-      // I don't really like this, but we need to get all of the settings
-      // before every request. This just sucks because its going to slow things
-      // down. Meh.
-      return server.uiSettings().getAll().then((uiSettings) => {
-        var sheet;
-        var tlConfig = require('../handlers/lib/tl_config.js')({
-          server: server,
-          request: request,
+        const tlConfig = require('../handlers/lib/tl_config.js')({
+          server,
+          request,
           settings: _.defaults(uiSettings, timelionDefaults) // Just in case they delete some setting.
         });
-        var chainRunner = chainRunnerFn(tlConfig);
-
-        try {
-          sheet = chainRunner.processRequest(request.payload || {
-            sheet: [request.query.expression],
-            time: {
-              from: request.query.from,
-              to: request.query.to,
-              interval: request.query.interval,
-              timezone: request.query.timezone
-            }
-          });
-        } catch (e) {
-          replyWithError(e, reply);
-          return;
-        }
 
-        return Promise.all(sheet).then((sheet) => {
-          var response = {
-            sheet: sheet,
-            stats: chainRunner.getStats()
-          };
-          reply(response);
-        }).catch((e) => {
-          // TODO Maybe we should just replace everywhere we throw with Boom? Probably.
-          if (e.isBoom) {
-            reply(e);
-          } else {
-            replyWithError(e, reply);
+        const chainRunner = chainRunnerFn(tlConfig);
+        const sheet = await Promise.all(chainRunner.processRequest(request.payload || {
+          sheet: [request.query.expression],
+          time: {
+            from: request.query.from,
+            to: request.query.to,
+            interval: request.query.interval,
+            timezone: request.query.timezone
           }
-        });
-      });
+        }));
 
+        reply({
+          sheet,
+          stats: chainRunner.getStats()
+        });
 
+      } catch (err) {
+        // TODO Maybe we should just replace everywhere we throw with Boom? Probably.
+        if (err.isBoom) {
+          reply(err);
+        } else {
+          replyWithError(err, reply);
+        }
+      }
     }
   });
 
diff --git a/src/core_plugins/timelion/server/routes/validate_es.js b/src/core_plugins/timelion/server/routes/validate_es.js
index 482c2fdac4d07..eaa625beca177 100644
--- a/src/core_plugins/timelion/server/routes/validate_es.js
+++ b/src/core_plugins/timelion/server/routes/validate_es.js
@@ -4,7 +4,7 @@ module.exports = function (server) {
     path: '/api/timelion/validate/es',
     handler: function (request, reply) {
 
-      return server.uiSettings().getAll().then((uiSettings) => {
+      return server.uiSettings().getAll(request).then((uiSettings) => {
         var callWithRequest = server.plugins.elasticsearch.callWithRequest;
 
         var timefield = uiSettings['timelion:es.timefield'];
diff --git a/src/server/http/__tests__/short_url_error.js b/src/server/http/__tests__/short_url_error.js
new file mode 100644
index 0000000000000..cdec714c73622
--- /dev/null
+++ b/src/server/http/__tests__/short_url_error.js
@@ -0,0 +1,32 @@
+import Boom from 'boom';
+import expect from 'expect.js';
+import _ from 'lodash';
+import { handleShortUrlError } from '../short_url_error';
+
+describe('handleShortUrlError()', () => {
+  const caughtErrors = [{
+    status: 401
+  }, {
+    status: 403
+  }, {
+    status: 404
+  }];
+
+  const uncaughtErrors = [{
+    status: null
+  }, {
+    status: 500
+  }];
+
+  caughtErrors.forEach((err) => {
+    it(`should handle ${err.status} errors`, function () {
+      expect(_.get(handleShortUrlError(err), 'output.statusCode')).to.be(err.status);
+    });
+  });
+
+  uncaughtErrors.forEach((err) => {
+    it(`should not handle unknown errors`, function () {
+      expect(_.get(handleShortUrlError(err), 'output.statusCode')).to.be(500);
+    });
+  });
+});
diff --git a/src/server/http/index.js b/src/server/http/index.js
index d5e015cc449cc..26358f4d9b30f 100644
--- a/src/server/http/index.js
+++ b/src/server/http/index.js
@@ -6,6 +6,7 @@ import Boom from 'boom';
 import Hapi from 'hapi';
 import getDefaultRoute from './get_default_route';
 import versionCheckMixin from './version_check';
+import { handleShortUrlError } from './short_url_error';
 import { shortUrlAssertValid } from './short_url_assert_valid';
 
 module.exports = async function (kbnServer, server, config) {
@@ -114,11 +115,11 @@ module.exports = async function (kbnServer, server, config) {
     path: '/goto/{urlId}',
     handler: async function (request, reply) {
       try {
-        const url = await shortUrlLookup.getUrl(request.params.urlId);
+        const url = await shortUrlLookup.getUrl(request.params.urlId, request);
         shortUrlAssertValid(url);
         reply().redirect(config.get('server.basePath') + url);
       } catch (err) {
-        reply(err);
+        reply(handleShortUrlError(err));
       }
     }
   });
@@ -129,10 +130,10 @@ module.exports = async function (kbnServer, server, config) {
     handler: async function (request, reply) {
       try {
         shortUrlAssertValid(request.payload.url);
-        const urlId = await shortUrlLookup.generateUrlId(request.payload.url);
+        const urlId = await shortUrlLookup.generateUrlId(request.payload.url, request);
         reply(urlId);
       } catch (err) {
-        reply(err);
+        reply(handleShortUrlError(err));
       }
     }
   });
diff --git a/src/server/http/short_url_error.js b/src/server/http/short_url_error.js
new file mode 100644
index 0000000000000..8c617a5fbf5fd
--- /dev/null
+++ b/src/server/http/short_url_error.js
@@ -0,0 +1,9 @@
+import Boom from 'boom';
+
+export function handleShortUrlError(err) {
+  if (err.isBoom) return err;
+  if (err.status === 401) return Boom.unauthorized();
+  if (err.status === 403) return Boom.forbidden();
+  if (err.status === 404) return Boom.notFound();
+  return Boom.badImplementation();
+}
diff --git a/src/server/http/short_url_lookup.js b/src/server/http/short_url_lookup.js
index 2f0d3b3764486..1341128c5ee99 100644
--- a/src/server/http/short_url_lookup.js
+++ b/src/server/http/short_url_lookup.js
@@ -1,12 +1,12 @@
 import crypto from 'crypto';
 
 export default function (server) {
-  async function updateMetadata(urlId, urlDoc) {
-    const client = server.plugins.elasticsearch.client;
+  async function updateMetadata(urlId, urlDoc, req) {
+    const callWithRequest = server.plugins.elasticsearch.callWithRequest;
     const kibanaIndex = server.config().get('kibana.index');
 
     try {
-      await client.update({
+      await callWithRequest(req, 'update', {
         index: kibanaIndex,
         type: 'url',
         id: urlId,
@@ -23,12 +23,12 @@ export default function (server) {
     }
   }
 
-  async function getUrlDoc(urlId) {
+  async function getUrlDoc(urlId, req) {
     const urlDoc = await new Promise((resolve, reject) => {
-      const client = server.plugins.elasticsearch.client;
+      const callWithRequest = server.plugins.elasticsearch.callWithRequest;
       const kibanaIndex = server.config().get('kibana.index');
 
-      client.get({
+      callWithRequest(req, 'get', {
         index: kibanaIndex,
         type: 'url',
         id: urlId
@@ -44,12 +44,12 @@ export default function (server) {
     return urlDoc;
   }
 
-  async function createUrlDoc(url, urlId) {
+  async function createUrlDoc(url, urlId, req) {
     const newUrlId = await new Promise((resolve, reject) => {
-      const client = server.plugins.elasticsearch.client;
+      const callWithRequest = server.plugins.elasticsearch.callWithRequest;
       const kibanaIndex = server.config().get('kibana.index');
 
-      client.index({
+      callWithRequest(req, 'index', {
         index: kibanaIndex,
         type: 'url',
         id: urlId,
@@ -80,19 +80,19 @@ export default function (server) {
   }
 
   return {
-    async generateUrlId(url) {
+    async generateUrlId(url, req) {
       const urlId = createUrlId(url);
-      const urlDoc = await getUrlDoc(urlId);
+      const urlDoc = await getUrlDoc(urlId, req);
       if (urlDoc) return urlId;
 
-      return createUrlDoc(url, urlId);
+      return createUrlDoc(url, urlId, req);
     },
-    async getUrl(urlId) {
+    async getUrl(urlId, req) {
       try {
-        const urlDoc = await getUrlDoc(urlId);
+        const urlDoc = await getUrlDoc(urlId, req);
         if (!urlDoc) throw new Error('Requested shortened url does not exist in kibana index');
 
-        updateMetadata(urlId, urlDoc);
+        updateMetadata(urlId, urlDoc, req);
 
         return urlDoc._source.url;
       } catch (err) {
diff --git a/src/server/status/index.js b/src/server/status/index.js
index 487621ba6a768..8838b7f6c250f 100644
--- a/src/server/status/index.js
+++ b/src/server/status/index.js
@@ -18,6 +18,9 @@ export default function (kbnServer, server, config) {
     handler: function (request, reply) {
       return reply({
         name: config.get('server.name'),
+        version: config.get('pkg.version'),
+        buildNum: config.get('pkg.buildNum'),
+        buildSha: config.get('pkg.buildSha'),
         uuid: config.get('server.uuid'),
         status: kbnServer.status.toJSON(),
         metrics: kbnServer.metrics
diff --git a/src/test_utils/stub_mapper.js b/src/test_utils/stub_mapper.js
new file mode 100644
index 0000000000000..edf1c349e89fb
--- /dev/null
+++ b/src/test_utils/stub_mapper.js
@@ -0,0 +1,17 @@
+import MapperService from 'ui/index_patterns/_mapper';
+import stubbedLogstashFields from 'fixtures/logstash_fields';
+import sinon from 'auto-release-sinon';
+
+export function stubMapper(Private, mockLogstashFields = Private(stubbedLogstashFields)) {
+  let stubbedMapper = Private(MapperService);
+
+  sinon.stub(stubbedMapper, 'getFieldsForIndexPattern', function () {
+    return Promise.resolve(mockLogstashFields.filter(field => field.scripted === false));
+  });
+
+  sinon.stub(stubbedMapper, 'clearCache', function () {
+    return Promise.resolve();
+  });
+
+  return stubbedMapper;
+}
diff --git a/src/ui/__tests__/ui_exports_replace_injected_vars.js b/src/ui/__tests__/ui_exports_replace_injected_vars.js
index fe578642eae84..9f4f714906b35 100644
--- a/src/ui/__tests__/ui_exports_replace_injected_vars.js
+++ b/src/ui/__tests__/ui_exports_replace_injected_vars.js
@@ -41,7 +41,7 @@ describe('UiExports', function () {
       await kbnServer.ready();
       kbnServer.status.get('ui settings').state = 'green';
       kbnServer.server.decorate('server', 'uiSettings', () => {
-        return { getDefaults: noop };
+        return { getDefaults: noop, getUserProvided: noop };
       });
     });
 
diff --git a/src/ui/index.js b/src/ui/index.js
index c88ec53c82e6f..be84d29effab3 100644
--- a/src/ui/index.js
+++ b/src/ui/index.js
@@ -1,6 +1,7 @@
 import { format as formatUrl } from 'url';
 import { readFileSync as readFile } from 'fs';
 import { defaults } from 'lodash';
+import { props } from 'bluebird';
 import Boom from 'boom';
 import { reduce as reduceAsync } from 'bluebird';
 import { resolve } from 'path';
@@ -61,7 +62,9 @@ export default async (kbnServer, server, config) => {
     }
   });
 
-  async function getPayload(app) {
+  async function getKibanaPayload({ app, request, includeUserProvidedConfig }) {
+    const uiSettings = server.uiSettings();
+
     return {
       app: app,
       nav: uiExports.navLinks.inOrder,
@@ -71,42 +74,47 @@ export default async (kbnServer, server, config) => {
       basePath: config.get('server.basePath'),
       serverName: config.get('server.name'),
       devMode: config.get('env.dev'),
-      uiSettings: {
-        defaults: await server.uiSettings().getDefaults(),
-        user: {}
-      },
+      uiSettings: await props({
+        defaults: uiSettings.getDefaults(),
+        user: includeUserProvidedConfig && uiSettings.getUserProvided(request)
+      }),
       vars: await reduceAsync(
         uiExports.injectedVarsReplacers,
-        async (acc, replacer) => await replacer(acc, this.request, server),
+        async (acc, replacer) => await replacer(acc, request, server),
         defaults(await app.getInjectedVars() || {}, uiExports.defaultInjectedVars)
-      )
+      ),
     };
   }
 
-  function viewAppWithPayload(app, payload) {
-    return this.view(app.templateName, {
-      app: app,
-      kibanaPayload: payload,
-      bundlePath: `${config.get('server.basePath')}/bundles`,
-    });
-  }
-
-  async function renderApp(app) {
-    const payload = await getPayload.call(this, app);
-
-    const esStatus = kbnServer.status.getForPluginId('elasticsearch');
-    if (esStatus && esStatus.state !== 'red') {
-      payload.uiSettings.user = await server.uiSettings().getUserProvided();
+  async function renderApp({ app, reply, includeUserProvidedConfig = true }) {
+    try {
+      return reply.view(app.templateName, {
+        app,
+        kibanaPayload: await getKibanaPayload({
+          app,
+          request: reply.request,
+          includeUserProvidedConfig
+        }),
+        bundlePath: `${config.get('server.basePath')}/bundles`,
+      });
+    } catch (err) {
+      reply(err);
     }
-
-    return viewAppWithPayload.call(this, app, payload);
   }
 
-  async function renderAppWithDefaultConfig(app) {
-    const payload = await getPayload.call(this, app);
-    return viewAppWithPayload.call(this, app, payload);
-  }
+  server.decorate('reply', 'renderApp', function (app) {
+    return renderApp({
+      app,
+      reply: this,
+      includeUserProvidedConfig: true,
+    });
+  });
 
-  server.decorate('reply', 'renderApp', renderApp);
-  server.decorate('reply', 'renderAppWithDefaultConfig', renderAppWithDefaultConfig);
+  server.decorate('reply', 'renderAppWithDefaultConfig', function (app) {
+    return renderApp({
+      app,
+      reply: this,
+      includeUserProvidedConfig: false,
+    });
+  });
 };
diff --git a/src/ui/public/agg_types/metrics/median.js b/src/ui/public/agg_types/metrics/median.js
index 0b01fbbd1b116..4c36b0d9a4de2 100644
--- a/src/ui/public/agg_types/metrics/median.js
+++ b/src/ui/public/agg_types/metrics/median.js
@@ -1,10 +1,8 @@
-import _ from 'lodash';
 import AggTypesMetricsMetricAggTypeProvider from 'ui/agg_types/metrics/metric_agg_type';
-import AggTypesMetricsGetResponseAggConfigClassProvider from 'ui/agg_types/metrics/get_response_agg_config_class';
 import AggTypesMetricsPercentilesProvider from 'ui/agg_types/metrics/percentiles';
 export default function AggTypeMetricMedianProvider(Private) {
+
   let MetricAggType = Private(AggTypesMetricsMetricAggTypeProvider);
-  let getResponseAggConfigClass = Private(AggTypesMetricsGetResponseAggConfigClassProvider);
   let percentiles = Private(AggTypesMetricsPercentilesProvider);
 
   return new MetricAggType({
diff --git a/src/ui/public/config/config.js b/src/ui/public/config/config.js
index 265e0b5dd6afe..d6cdbc144f8df 100644
--- a/src/ui/public/config/config.js
+++ b/src/ui/public/config/config.js
@@ -91,7 +91,12 @@ any custom setting configuration watchers for "${key}" may fix this issue.`);
     if (value === null) {
       delete settings[key].userValue;
     } else {
-      settings[key].userValue = value;
+      const { type } = settings[key];
+      if (type === 'json' && typeof value !== 'string') {
+        settings[key].userValue = angular.toJson(value);
+      } else {
+        settings[key].userValue = value;
+      }
     }
   }
 
diff --git a/src/ui/public/courier/__tests__/saved_object.js b/src/ui/public/courier/__tests__/saved_object.js
new file mode 100644
index 0000000000000..829dc26e35fe1
--- /dev/null
+++ b/src/ui/public/courier/__tests__/saved_object.js
@@ -0,0 +1,364 @@
+/**
+ * Tests functionality in ui/public/courier/saved_object/saved_object.js
+ */
+
+import ngMock from 'ng_mock';
+import expect from 'expect.js';
+import sinon from 'auto-release-sinon';
+
+import BluebirdPromise from 'bluebird';
+import SavedObjectFactory from '../saved_object/saved_object';
+import { stubMapper } from 'test_utils/stub_mapper';
+import IndexPatternFactory from 'ui/index_patterns/_index_pattern';
+
+describe('Saved Object', function () {
+  require('test_utils/no_digest_promises').activateForSuite();
+
+  let SavedObject;
+  let IndexPattern;
+  let esStub;
+
+  /**
+   * Some default es stubbing to avoid timeouts and allow a default type of 'dashboard'.
+   */
+  function mockEsService() {
+    // Allows the type 'dashboard' to be used.
+    // Unfortunately we need to use bluebird here instead of native promises because there is
+    // a call to finally.
+    sinon.stub(esStub.indices, 'getFieldMapping').returns(BluebirdPromise.resolve({
+      '.kibana' : {
+        'mappings': {
+          'dashboard': {}
+        }
+      }
+    }));
+
+    // Necessary to avoid a timeout condition.
+    sinon.stub(esStub.indices, 'putMapping').returns(BluebirdPromise.resolve());
+  }
+
+  /**
+   * Returns a fake doc response with the given index and id, of type dashboard
+   * that can be used to stub es calls.
+   * @param indexPatternId
+   * @param additionalOptions - object that will be assigned to the mocked doc response.
+   * @returns {{_source: {}, _index: *, _type: string, _id: *, found: boolean}}
+   */
+  function getMockedDocResponse(indexPatternId, additionalOptions = {}) {
+    return Object.assign(
+      {
+        _source: {},
+        _index: indexPatternId,
+        _type: 'dashboard',
+        _id: indexPatternId,
+        found: true
+      },
+      additionalOptions);
+  }
+
+  /**
+   * Stubs some of the es retrieval calls so it returns the given response.
+   * @param {Object} mockDocResponse
+   */
+  function stubESResponse(mockDocResponse) {
+    sinon.stub(esStub, 'mget').returns(BluebirdPromise.resolve({ docs: [mockDocResponse] }));
+    sinon.stub(esStub, 'index').returns(BluebirdPromise.resolve(mockDocResponse));
+  }
+
+  /**
+   * Creates a new saved object with the given configuration and initializes it.
+   * Returns the promise that will be completed when the initialization finishes.
+   *
+   * @param {Object} config
+   * @returns {Promise<SavedObject>} A promise that resolves with an instance of
+   * SavedObject
+   */
+  function createInitializedSavedObject(config = {}) {
+    let savedObject = new SavedObject(config);
+    return savedObject.init();
+  }
+
+  beforeEach(ngMock.module('kibana'));
+  beforeEach(ngMock.inject(function (es, Private) {
+    SavedObject = Private(SavedObjectFactory);
+    IndexPattern = Private(IndexPatternFactory);
+    esStub = es;
+
+    mockEsService();
+    stubMapper(Private);
+  }));
+
+  describe('applyESResp', function () {
+    it('throws error if not found', function () {
+      return createInitializedSavedObject({ type: 'dashboard' }).then(savedObject => {
+        const response = {found: false};
+        try {
+          savedObject.applyESResp(response);
+          expect(true).to.be(false);
+        } catch (err) {
+          expect(!!err).to.be(true);
+        }
+      });
+    });
+
+    it('preserves original defaults if not overridden', function () {
+      const id = 'anid';
+      const preserveMeValue = 'here to stay!';
+      const config = {
+        defaults: {
+          preserveMe: preserveMeValue
+        },
+        type: 'dashboard',
+        id: id
+      };
+
+      const mockDocResponse = getMockedDocResponse(id);
+      stubESResponse(mockDocResponse);
+
+      const savedObject = new SavedObject(config);
+      return savedObject.init()
+        .then(() => {
+          expect(savedObject._source.preserveMe).to.equal(preserveMeValue);
+          const response = {found: true, _source: {}};
+          return savedObject.applyESResp(response);
+        }).then(() => {
+          expect(savedObject._source.preserveMe).to.equal(preserveMeValue);
+        });
+    });
+
+    it('overrides defaults', function () {
+      const id = 'anid';
+      const config = {
+        defaults: {
+          flower: 'rose'
+        },
+        type: 'dashboard',
+        id: id
+      };
+
+      const mockDocResponse = getMockedDocResponse(id);
+      stubESResponse(mockDocResponse);
+
+      const savedObject = new SavedObject(config);
+      return savedObject.init()
+        .then(() => {
+          expect(savedObject._source.flower).to.equal('rose');
+          const response = {
+            found: true,
+            _source: {
+              flower: 'orchid'
+            }
+          };
+          return savedObject.applyESResp(response);
+        }).then(() => {
+          expect(savedObject._source.flower).to.equal('orchid');
+        });
+    });
+
+    it('overrides previous _source and default values', function () {
+      const id = 'anid';
+      const config = {
+        defaults: {
+          dinosaurs: {
+            tRex: 'is the scariest'
+          }
+        },
+        type: 'dashboard',
+        id: id
+      };
+
+      const mockDocResponse = getMockedDocResponse(
+        id,
+        { _source: { dinosaurs: { tRex: 'is not so bad'}, } });
+      stubESResponse(mockDocResponse);
+
+
+      let savedObject = new SavedObject(config);
+      return savedObject.init()
+        .then(() => {
+          const response = {
+            found: true,
+            _source: { dinosaurs: { tRex: 'has big teeth' } }
+          };
+
+          return savedObject.applyESResp(response);
+        })
+        .then(() => {
+          expect(savedObject._source.dinosaurs.tRex).to.equal('has big teeth');
+        });
+    });
+
+  });
+
+  describe ('config', function () {
+
+    it('afterESResp is called', function () {
+      const afterESRespCallback = sinon.spy();
+      const config = {
+        type: 'dashboard',
+        afterESResp: afterESRespCallback
+      };
+
+      return createInitializedSavedObject(config).then(() => {
+        expect(afterESRespCallback.called).to.be(true);
+      });
+    });
+
+    it('init is called', function () {
+      const initCallback = sinon.spy();
+      const config = {
+        type: 'dashboard',
+        init: initCallback
+      };
+
+      return createInitializedSavedObject(config).then(() => {
+        expect(initCallback.called).to.be(true);
+      });
+    });
+
+    describe('searchSource', function () {
+
+      it('when true, creates index', function () {
+        const indexPatternId = 'testIndexPattern';
+        const afterESRespCallback = sinon.spy();
+
+        const config = {
+          type: 'dashboard',
+          afterESResp: afterESRespCallback,
+          searchSource: true,
+          indexPattern: indexPatternId
+        };
+
+        stubESResponse(getMockedDocResponse(indexPatternId));
+
+        const savedObject = new SavedObject(config);
+        expect(!!savedObject.searchSource.get('index')).to.be(false);
+
+        return savedObject.init().then(() => {
+          expect(afterESRespCallback.called).to.be(true);
+          const index = savedObject.searchSource.get('index');
+          expect(index instanceof IndexPattern).to.be(true);
+          expect(index.id).to.equal(indexPatternId);
+        });
+      });
+
+      it('when false, does not create index', function () {
+        const indexPatternId = 'testIndexPattern';
+        const afterESRespCallback = sinon.spy();
+
+        const config = {
+          type: 'dashboard',
+          afterESResp: afterESRespCallback,
+          searchSource: false,
+          indexPattern: indexPatternId
+        };
+
+        stubESResponse(getMockedDocResponse(indexPatternId));
+
+        const savedObject = new SavedObject(config);
+        expect(!!savedObject.searchSource).to.be(false);
+
+        return savedObject.init().then(() => {
+          expect(afterESRespCallback.called).to.be(true);
+          expect(!!savedObject.searchSource).to.be(false);
+        });
+      });
+    });
+
+    describe('type', function () {
+      it('that is not specified throws an error', function () {
+        const config = {};
+
+        const savedObject = new SavedObject(config);
+        try {
+          savedObject.init();
+          expect(false).to.be(true);
+        } catch (err) {
+          expect(err).to.not.be(null);
+        }
+      });
+
+      it('that is invalid invalid throws an error', function () {
+        const config = { type: 'notypeexists' };
+
+        const savedObject = new SavedObject(config);
+        try {
+          savedObject.init();
+          expect(false).to.be(true);
+        } catch (err) {
+          expect(err).to.not.be(null);
+        }
+      });
+
+      it('that is valid passes', function () {
+        const config = { type: 'dashboard' };
+        return new SavedObject(config).init();
+      });
+    });
+
+    describe('defaults', function () {
+
+      function getTestDefaultConfig(extraOptions) {
+        return Object.assign({
+          defaults: { testDefault: 'hi' },
+          type: 'dashboard'
+        }, extraOptions);
+      }
+
+      function expectDefaultApplied(config) {
+        return createInitializedSavedObject(config).then((savedObject) => {
+          expect(savedObject.defaults).to.be(config.defaults);
+        });
+      }
+
+      describe('applied to object when id', function () {
+
+        it('is not specified', function () {
+          expectDefaultApplied(getTestDefaultConfig());
+        });
+
+        it('is undefined', function () {
+          expectDefaultApplied(getTestDefaultConfig({ id: undefined }));
+        });
+
+        it('is 0', function () {
+          expectDefaultApplied(getTestDefaultConfig({ id: 0 }));
+        });
+
+        it('is false', function () {
+          expectDefaultApplied(getTestDefaultConfig({ id: false }));
+        });
+      });
+
+      it('applied to source if an id is given', function () {
+        const myId = 'myid';
+        const customDefault = 'hi';
+        const initialOverwriteMeValue = 'this should get overwritten by the server response';
+
+        const config = {
+          defaults: {
+            overwriteMe: initialOverwriteMeValue,
+            customDefault: customDefault
+          },
+          type: 'dashboard',
+          id: myId
+        };
+
+        const serverValue = 'this should override the initial default value given';
+
+        const mockDocResponse = getMockedDocResponse(
+          myId,
+          { _source: { overwriteMe: serverValue } });
+
+        stubESResponse(mockDocResponse);
+
+        return createInitializedSavedObject(config).then((savedObject) => {
+          expect(!!savedObject._source).to.be(true);
+          expect(savedObject.defaults).to.be(config.defaults);
+          expect(savedObject._source.overwriteMe).to.be(serverValue);
+          expect(savedObject._source.customDefault).to.be(customDefault);
+        });
+      });
+    });
+  });
+});
diff --git a/src/ui/public/directives/render_counter.js b/src/ui/public/directives/render_counter.js
new file mode 100644
index 0000000000000..0a2ec78574f99
--- /dev/null
+++ b/src/ui/public/directives/render_counter.js
@@ -0,0 +1,31 @@
+import uiModules from 'ui/modules';
+
+uiModules
+  .get('kibana')
+  .directive('renderCounter', () => ({
+    controller($scope, $element) {
+      let counter = 0;
+
+      const increment = () => {
+        counter += 1;
+        $element.attr('render-counter', counter);
+      };
+
+      const teardown = () => {
+        $element.off('renderComplete', increment);
+      };
+
+      const setup = () => {
+        $element.attr('render-counter', counter);
+        $element.on('renderComplete', increment);
+        $scope.$on('$destroy', teardown);
+      };
+
+      this.disable = () => {
+        $element.attr('render-counter', 'disabled');
+        teardown();
+      };
+
+      setup();
+    }
+  }));
diff --git a/src/ui/public/doc_table/components/table_row.js b/src/ui/public/doc_table/components/table_row.js
index 530ddb996c3a9..c8cab43acb329 100644
--- a/src/ui/public/doc_table/components/table_row.js
+++ b/src/ui/public/doc_table/components/table_row.js
@@ -40,10 +40,6 @@ module.directive('kbnTableRow', function ($compile) {
       $el.after('<tr>');
       $el.empty();
 
-      let init = function () {
-        createSummaryRow($scope.row, $scope.row._id);
-      };
-
       // when we compile the details, we use this $scope
       let $detailsScope;
 
@@ -79,11 +75,11 @@ module.directive('kbnTableRow', function ($compile) {
         $compile($detailsTr)($detailsScope);
       };
 
-      $scope.$watchCollection('columns', function () {
-        createSummaryRow($scope.row, $scope.row._id);
-      });
-
-      $scope.$watchMulti(['indexPattern.timeFieldName', 'row.highlight'], function () {
+      $scope.$watchMulti([
+        'indexPattern.timeFieldName',
+        'row.highlight',
+        '[]columns'
+      ], function () {
         createSummaryRow($scope.row, $scope.row._id);
       });
 
@@ -144,6 +140,7 @@ module.directive('kbnTableRow', function ($compile) {
 
         // trim off cells that were not used rest of the cells
         $cells.filter(':gt(' + (newHtmls.length - 1) + ')').remove();
+        $el.trigger('renderComplete');
       }
 
       /**
@@ -161,8 +158,6 @@ module.directive('kbnTableRow', function ($compile) {
 
         return text;
       }
-
-      init();
     }
   };
 });
diff --git a/src/ui/public/doc_table/doc_table.html b/src/ui/public/doc_table/doc_table.html
index 68cd1e0c3d4f2..1f7f0c0c90ce0 100644
--- a/src/ui/public/doc_table/doc_table.html
+++ b/src/ui/public/doc_table/doc_table.html
@@ -43,4 +43,4 @@
 <div ng-if="hits != null && !hits.length" class="table-vis-error">
   <h2><i class="fa fa-meh-o"></i></h2>
   <h4>No results found</h4>
-</div>
\ No newline at end of file
+</div>
diff --git a/src/ui/public/documentation_links/documentation_links.js b/src/ui/public/documentation_links/documentation_links.js
index 36f83e0e969cd..e1b9013a04915 100644
--- a/src/ui/public/documentation_links/documentation_links.js
+++ b/src/ui/public/documentation_links/documentation_links.js
@@ -12,7 +12,7 @@ export default {
     configuration: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/filebeat-configuration.html`,
     elasticsearchOutput: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/elasticsearch-output.html`,
     elasticsearchOutputAnchorParameters: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/elasticsearch-output.html#_parameters`,
-    startup: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/_step_5_starting_filebeat.html`,
+    startup: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/filebeat-starting.html`,
     exportedFields: `${baseUrl}guide/en/beats/filebeat/${urlVersion}/exported-fields.html`
   },
   scriptedFields: {
diff --git a/src/ui/public/draggable/draggable_container.js b/src/ui/public/draggable/draggable_container.js
index 1d5d6b6bd2804..ea1df9894210e 100644
--- a/src/ui/public/draggable/draggable_container.js
+++ b/src/ui/public/draggable/draggable_container.js
@@ -7,19 +7,26 @@ uiModules
 .get('kibana')
 .directive('draggableContainer', function () {
 
+  const $scopes = new WeakMap();
+
   return {
     restrict: 'A',
     scope: true,
     controllerAs: 'draggableContainerCtrl',
-    controller($scope, $attrs, $parse) {
+    controller($scope, $attrs, $parse, $element) {
+      $scopes.set($element.get(0), $scope);
+      this.linkDraggableItem = (el, $scope) => {
+        $scopes.set(el, $scope);
+      };
+
       this.getList = () => $parse($attrs.draggableContainer)($scope);
     },
     link($scope, $el, attr) {
       const drake = dragula({
         containers: $el.toArray(),
         moves(el, source, handle) {
-          const itemScope = $(el).scope();
-          if (!('draggableItemCtrl' in itemScope)) {
+          const itemScope = $scopes.get(el);
+          if (!itemScope || !('draggableItemCtrl' in itemScope)) {
             return; // only [draggable-item] is draggable
           }
           return itemScope.draggableItemCtrl.moves(handle);
@@ -53,7 +60,8 @@ uiModules
 
       function markDragging(isDragging) {
         return el => {
-          const scope = $(el).scope();
+          const scope = $scopes.get(el);
+          if (!scope) return;
           scope.isDragging = isDragging;
           scope.$apply();
         };
@@ -61,13 +69,15 @@ uiModules
 
       function forwardEvent(type, el, ...args) {
         const name = `drag-${prettifiedDrakeEvents[type] || type}`;
-        const scope = $(el).scope();
+        const scope = $scopes.get(el);
+        if (!scope) return;
         scope.$broadcast(name, el, ...args);
       }
 
       function drop(el, target, source, sibling) {
         const list = $scope.draggableContainerCtrl.getList();
-        const itemScope = $(el).scope();
+        const itemScope = $scopes.get(el);
+        if (!itemScope) return;
         const item = itemScope.draggableItemCtrl.getItem();
         const fromIndex = list.indexOf(item);
         const siblingIndex = getItemIndexFromElement(list, sibling);
@@ -91,7 +101,8 @@ uiModules
       function getItemIndexFromElement(list, element) {
         if (!element) return -1;
 
-        const scope = $(element).scope();
+        const scope = $scopes.get(element);
+        if (!scope) return;
         const item = scope.draggableItemCtrl.getItem();
         const index = list.indexOf(item);
 
diff --git a/src/ui/public/draggable/draggable_item.js b/src/ui/public/draggable/draggable_item.js
index ff46c7a5d4de2..2c11c3b315455 100644
--- a/src/ui/public/draggable/draggable_item.js
+++ b/src/ui/public/draggable/draggable_item.js
@@ -23,7 +23,8 @@ uiModules
         return movable;
       };
     },
-    link($scope, $el, attr) {
+    link($scope, $el, attr, draggableController) {
+      draggableController.linkDraggableItem($el.get(0), $scope);
     }
   };
 });
diff --git a/src/ui/public/index_patterns/__tests__/_index_pattern.js b/src/ui/public/index_patterns/__tests__/_index_pattern.js
index 98b26aea61b06..5acab51892973 100644
--- a/src/ui/public/index_patterns/__tests__/_index_pattern.js
+++ b/src/ui/public/index_patterns/__tests__/_index_pattern.js
@@ -8,11 +8,11 @@ import IndexedArray from 'ui/indexed_array';
 import FixturesLogstashFieldsProvider from 'fixtures/logstash_fields';
 import FixturesStubbedDocSourceResponseProvider from 'fixtures/stubbed_doc_source_response';
 import DocSourceProvider from 'ui/courier/data_source/doc_source';
-import IndexPatternsMapperProvider from 'ui/index_patterns/_mapper';
 import UtilsMappingSetupProvider from 'ui/utils/mapping_setup';
 import IndexPatternsIntervalsProvider from 'ui/index_patterns/_intervals';
 import IndexPatternsIndexPatternProvider from 'ui/index_patterns/_index_pattern';
 import NoDigestPromises from 'test_utils/no_digest_promises';
+import { stubMapper } from 'test_utils/stub_mapper';
 
 describe('index pattern', function () {
   NoDigestPromises.activateForSuite();
@@ -40,15 +40,7 @@ describe('index pattern', function () {
     DocSource = Private(DocSourceProvider);
     sinon.stub(DocSource.prototype, 'doIndex');
     sinon.stub(DocSource.prototype, 'fetch');
-
-    // stub mapper
-    mapper = Private(IndexPatternsMapperProvider);
-    sinon.stub(mapper, 'getFieldsForIndexPattern', function () {
-      return Promise.resolve(_.filter(mockLogstashFields, { scripted: false }));
-    });
-    sinon.stub(mapper, 'clearCache', function () {
-      return Promise.resolve();
-    });
+    mapper = stubMapper(Private, mockLogstashFields);
 
     // stub mappingSetup
     mappingSetup = Private(UtilsMappingSetupProvider);
diff --git a/src/ui/public/promises/__tests__/promises.js b/src/ui/public/promises/__tests__/promises.js
index 9ded576e76cf3..3cbbe45be80c4 100644
--- a/src/ui/public/promises/__tests__/promises.js
+++ b/src/ui/public/promises/__tests__/promises.js
@@ -22,6 +22,12 @@ describe('Promise service', function () {
     });
   });
 
+  it('Promise.resolve', function (done) {
+    Promise.resolve(true).then(() => { done(); });
+    // Ugly, but necessary for promises to resolve: https://github.com/angular/angular.js/issues/12555
+    $rootScope.$apply();
+  });
+
   describe('Promise.fromNode', function () {
     it('creates a callback that controls a promise', function () {
       let callback;
diff --git a/src/ui/public/template_vis_type/template_vis_type.js b/src/ui/public/template_vis_type/template_vis_type.js
index 3203b047ac583..70509d53da677 100644
--- a/src/ui/public/template_vis_type/template_vis_type.js
+++ b/src/ui/public/template_vis_type/template_vis_type.js
@@ -6,7 +6,7 @@ export default function TemplateVisTypeFactory(Private) {
   let TemplateRenderbot = Private(TemplateVisTypeTemplateRenderbotProvider);
 
   _.class(TemplateVisType).inherits(VisType);
-  function TemplateVisType(opts) {
+  function TemplateVisType(opts = {}) {
     TemplateVisType.Super.call(this, opts);
 
     this.template = opts.template;
diff --git a/src/ui/public/vis/vis.js b/src/ui/public/vis/vis.js
index ecfc7e730a62d..b92735498ba48 100644
--- a/src/ui/public/vis/vis.js
+++ b/src/ui/public/vis/vis.js
@@ -20,14 +20,12 @@ export default function VisFactory(Notifier, Private) {
   let visTypes = Private(RegistryVisTypesProvider);
   let AggConfigs = Private(VisAggConfigsProvider);
   const PersistedState = Private(PersistedStateProvider);
-  const EventEmitter = Private(EventsProvider);
 
   let notify = new Notifier({
     location: 'Vis'
   });
 
   function Vis(indexPattern, state, uiState) {
-    EventEmitter.call(this);
     state = state || {};
 
     if (_.isString(state)) {
@@ -40,8 +38,6 @@ export default function VisFactory(Notifier, Private) {
 
     this.setState(state);
     this.setUiState(uiState);
-
-    this.on('renderComplete', () => this._renderComplete = true);
   }
 
   Vis.convertOldState = function (type, oldState) {
@@ -85,7 +81,6 @@ export default function VisFactory(Notifier, Private) {
     };
   };
 
-  Vis.prototype = Object.create(EventEmitter.prototype);
   Vis.prototype.type = 'histogram';
 
   Vis.prototype.setState = function (state) {
@@ -173,14 +168,6 @@ export default function VisFactory(Notifier, Private) {
     return this.type.implementsRenderComplete;
   };
 
-  Vis.prototype.onRenderComplete = function (cb) {
-    this.on('renderComplete', cb);
-    if (this._renderComplete) {
-      // guarantees that caller receives event in case visualization already finished rendering
-      this.emit('renderComplete');
-    }
-  };
-
   /**
    * Currently this is only used to extract map-specific information
    * (e.g. mapZoom, mapCenter).
diff --git a/src/ui/public/vis/vis_type.js b/src/ui/public/vis/vis_type.js
index 03f963734cc61..7faf37b5dea66 100644
--- a/src/ui/public/vis/vis_type.js
+++ b/src/ui/public/vis/vis_type.js
@@ -15,7 +15,7 @@ export default function VisTypeFactory(Private) {
     this.schemas = opts.schemas || new VisTypeSchemas();
     this.params = opts.params || {};
     this.requiresSearch = opts.requiresSearch == null ? true : opts.requiresSearch; // Default to true unless otherwise specified
-    this.implementsRenderComplete = false;
+    this.implementsRenderComplete = opts.implementsRenderComplete || false;
   }
 
   VisType.prototype.createRenderbot = function (vis, $el, uiState) {
diff --git a/src/ui/public/vislib/lib/handler/handler.js b/src/ui/public/vislib/lib/handler/handler.js
index 68b9987164745..6d5885020f024 100644
--- a/src/ui/public/vislib/lib/handler/handler.js
+++ b/src/ui/public/vislib/lib/handler/handler.js
@@ -1,5 +1,6 @@
 import d3 from 'd3';
 import _ from 'lodash';
+import $ from 'jquery';
 import errors from 'ui/errors';
 import Binder from 'ui/binder';
 import VislibLibDataProvider from 'ui/vislib/lib/data';
@@ -126,8 +127,8 @@ export default function HandlerBaseClass(Private) {
         binder.on(chart.events, 'rendered', () => {
           loadedCount++;
           if (loadedCount === chartSelection.length) {
-            // events from all charts are propagated to vis, we only need to fire renderComplete on one (first)
-            charts[0].events.emit('renderComplete');
+            // events from all charts are propagated to vis, we only need to fire renderComplete once they all finish
+            $(self.el).trigger('renderComplete');
           }
         });
 
@@ -184,11 +185,11 @@ export default function HandlerBaseClass(Private) {
         .append('h4').text(message);
 
         div.append('div').attr('class', 'item bottom');
-        return div;
       } else {
         div.append('h4').text(message);
       }
-      this.vis.emit('renderComplete');
+
+      $(this.el).trigger('renderComplete');
       return div;
     };
 
diff --git a/src/ui/public/vislib_vis_type/__tests__/_vislib_renderbot.js b/src/ui/public/vislib_vis_type/__tests__/_vislib_renderbot.js
index 5e1e1f8bc6988..654bb5f01d5f9 100644
--- a/src/ui/public/vislib_vis_type/__tests__/_vislib_renderbot.js
+++ b/src/ui/public/vislib_vis_type/__tests__/_vislib_renderbot.js
@@ -77,7 +77,7 @@ describe('renderbot', function exportWrapper() {
     });
 
     it('should attach listeners and set vislibVis', function () {
-      expect(listenerSpy.callCount).to.be(4);
+      expect(listenerSpy.callCount).to.be(3);
       expect(listenerSpy.calledWith('test', _.noop)).to.be(true);
       expect(renderbot.vislibVis).to.be.a(Vis);
     });
diff --git a/src/ui/public/vislib_vis_type/vislib_renderbot.js b/src/ui/public/vislib_vis_type/vislib_renderbot.js
index dea21e72df926..20787334fb787 100644
--- a/src/ui/public/vislib_vis_type/vislib_renderbot.js
+++ b/src/ui/public/vislib_vis_type/vislib_renderbot.js
@@ -24,10 +24,6 @@ module.exports = function VislibRenderbotFactory(Private, $injector) {
       this.vislibVis.on(event, listener);
     });
 
-    this.vislibVis.on('renderComplete', () => {
-      this.vis.emit('renderComplete');
-    });
-
     if (this.chartData) {
       this.vislibVis.render(this.chartData, this.uiState);
     }
diff --git a/src/ui/public/vislib_vis_type/vislib_vis_type.js b/src/ui/public/vislib_vis_type/vislib_vis_type.js
index f16e768cdfd5f..40a58d5347166 100644
--- a/src/ui/public/vislib_vis_type/vislib_vis_type.js
+++ b/src/ui/public/vislib_vis_type/vislib_vis_type.js
@@ -16,9 +16,7 @@ export default function VislibVisTypeFactory(Private) {
 
 
   _.class(VislibVisType).inherits(VisType);
-  function VislibVisType(opts) {
-    opts = opts || {};
-
+  function VislibVisType(opts = {}) {
     VislibVisType.Super.call(this, opts);
 
     if (this.responseConverter == null) {
@@ -26,7 +24,6 @@ export default function VislibVisTypeFactory(Private) {
     }
 
     this.listeners = opts.listeners || {};
-    this.implementsRenderComplete = true;
   }
 
   VislibVisType.prototype.createRenderbot = function (vis, $el, uiState) {
diff --git a/src/ui/public/visualize/visualize.js b/src/ui/public/visualize/visualize.js
index a0c07675da311..39e9885bc5eb7 100644
--- a/src/ui/public/visualize/visualize.js
+++ b/src/ui/public/visualize/visualize.js
@@ -25,6 +25,7 @@ uiModules
 
   return {
     restrict: 'E',
+    require: '?renderCounter',
     scope : {
       showSpyPanel: '=?',
       vis: '=',
@@ -34,7 +35,7 @@ uiModules
       esResp: '=?',
     },
     template: visualizeTemplate,
-    link: function ($scope, $el, attr) {
+    link: function ($scope, $el, attr, renderCounter) {
       const minVisChartHeight = 180;
 
       if (_.isUndefined($scope.showSpyPanel)) {
@@ -72,6 +73,10 @@ uiModules
         return legendPositionToVisContainerClassMap[$scope.vis.params.legendPosition];
       };
 
+      if (renderCounter && !$scope.vis.implementsRenderComplete()) {
+        renderCounter.disable();
+      }
+
       $scope.spy = {};
       $scope.spy.mode = ($scope.uiState) ? $scope.uiState.get('spy.mode', {}) : {};
 
@@ -168,7 +173,7 @@ uiModules
         }).catch(notify.fatal);
 
         searchSource.onError(e => {
-          $scope.vis.emit('renderComplete');
+          $el.trigger('renderComplete');
           if (isTermSizeZeroError(e)) {
             return notify.error(
               `Your visualization ('${$scope.vis.title}') has an error: it has a term ` +
@@ -194,6 +199,7 @@ uiModules
 
       $scope.$on('$destroy', function () {
         if ($scope.renderbot) {
+          $el.off('renderComplete');
           $scope.renderbot.destroy();
         }
       });
diff --git a/src/ui/settings/__tests__/index.js b/src/ui/settings/__tests__/index.js
index c3393ec5135ae..344552abdce81 100644
--- a/src/ui/settings/__tests__/index.js
+++ b/src/ui/settings/__tests__/index.js
@@ -3,6 +3,7 @@ import sinon from 'sinon';
 import expect from 'expect.js';
 import init from '..';
 import defaultsProvider from '../defaults';
+import { errors as esErrors } from 'elasticsearch';
 
 describe('ui settings', function () {
   describe('overview', function () {
@@ -22,23 +23,23 @@ describe('ui settings', function () {
 
   describe('#setMany()', function () {
     it('returns a promise', () => {
-      const { uiSettings } = instantiate();
-      const result = uiSettings.setMany({ a: 'b' });
+      const { uiSettings, req } = instantiate();
+      const result = uiSettings.setMany(req, { a: 'b' });
       expect(result).to.be.a(Promise);
     });
 
     it('updates a single value in one operation', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.setMany({ one: 'value' });
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.setMany(req, { one: 'value' });
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: 'value'
       });
     });
 
     it('updates several values in one operation', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.setMany({ one: 'value', another: 'val' });
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.setMany(req, { one: 'value', another: 'val' });
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: 'value', another: 'val'
       });
     });
@@ -46,15 +47,15 @@ describe('ui settings', function () {
 
   describe('#set()', function () {
     it('returns a promise', () => {
-      const { uiSettings } = instantiate();
-      const result = uiSettings.set('a', 'b');
+      const { uiSettings, req } = instantiate();
+      const result = uiSettings.set(req, 'a', 'b');
       expect(result).to.be.a(Promise);
     });
 
     it('updates single values by (key, value)', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.set('one', 'value');
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.set(req, 'one', 'value');
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: 'value'
       });
     });
@@ -62,15 +63,15 @@ describe('ui settings', function () {
 
   describe('#remove()', function () {
     it('returns a promise', () => {
-      const { uiSettings } = instantiate();
-      const result = uiSettings.remove('one');
+      const { uiSettings, req } = instantiate();
+      const result = uiSettings.remove(req, 'one');
       expect(result).to.be.a(Promise);
     });
 
     it('removes single values by key', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.remove('one');
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.remove(req, 'one');
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: null
       });
     });
@@ -78,23 +79,23 @@ describe('ui settings', function () {
 
   describe('#removeMany()', function () {
     it('returns a promise', () => {
-      const { uiSettings } = instantiate();
-      const result = uiSettings.removeMany(['one']);
+      const { uiSettings, req } = instantiate();
+      const result = uiSettings.removeMany(req, ['one']);
       expect(result).to.be.a(Promise);
     });
 
     it('removes a single value', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.removeMany(['one']);
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.removeMany(req, ['one']);
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: null
       });
     });
 
     it('updates several values in one operation', function () {
-      const { server, uiSettings, configGet } = instantiate();
-      const result = uiSettings.removeMany(['one', 'two', 'three']);
-      expectElasticsearchUpdateQuery(server, configGet, {
+      const { server, uiSettings, configGet, req } = instantiate();
+      const result = uiSettings.removeMany(req, ['one', 'two', 'three']);
+      expectElasticsearchUpdateQuery(server, req, configGet, {
         one: null, two: null, three: null
       });
     });
@@ -134,15 +135,15 @@ describe('ui settings', function () {
   describe('#getUserProvided()', function () {
     it('pulls user configuration from ES', async function () {
       const getResult = { user: 'customized' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getUserProvided();
-      expectElasticsearchGetQuery(server, configGet);
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getUserProvided(req);
+      expectElasticsearchGetQuery(server, req, configGet);
     });
 
     it('returns user configuration', async function () {
       const getResult = { user: 'customized' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getUserProvided();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getUserProvided(req);
       expect(isEqual(result, {
         user: { userValue: 'customized' }
       })).to.equal(true);
@@ -150,33 +151,95 @@ describe('ui settings', function () {
 
     it('ignores null user configuration (because default values)', async function () {
       const getResult = { user: 'customized', usingDefault: null, something: 'else' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getUserProvided();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getUserProvided(req);
       expect(isEqual(result, {
         user: { userValue: 'customized' }, something: { userValue: 'else' }
       })).to.equal(true);
     });
+
+    it('returns an empty object on 404 responses', async function () {
+      const { uiSettings, req } = instantiate({
+        async callWithRequest() {
+          throw new esErrors[404]();
+        }
+      });
+
+      expect(await uiSettings.getUserProvided(req)).to.eql({});
+    });
+
+    it('returns an empty object on 403 responses', async function () {
+      const { uiSettings, req } = instantiate({
+        async callWithRequest() {
+          throw new esErrors[403]();
+        }
+      });
+
+      expect(await uiSettings.getUserProvided(req)).to.eql({});
+    });
+
+    it('returns an empty object on NoConnections responses', async function () {
+      const { uiSettings, req } = instantiate({
+        async callWithRequest() {
+          throw new esErrors.NoConnections();
+        }
+      });
+
+      expect(await uiSettings.getUserProvided(req)).to.eql({});
+    });
+
+    it('throws 401 errors', async function () {
+      const { uiSettings, req } = instantiate({
+        async callWithRequest() {
+          throw new esErrors[401]();
+        }
+      });
+
+      try {
+        await uiSettings.getUserProvided(req);
+        throw new Error('expect getUserProvided() to throw');
+      } catch (err) {
+        expect(err).to.be.a(esErrors[401]);
+      }
+    });
+
+    it('throw when callWithRequest fails in some unexpected way', async function () {
+      const expectedUnexpectedError = new Error('unexpected');
+
+      const { uiSettings, req } = instantiate({
+        async callWithRequest() {
+          throw expectedUnexpectedError;
+        }
+      });
+
+      try {
+        await uiSettings.getUserProvided(req);
+        throw new Error('expect getUserProvided() to throw');
+      } catch (err) {
+        expect(err).to.be(expectedUnexpectedError);
+      }
+    });
   });
 
   describe('#getRaw()', function () {
     it('pulls user configuration from ES', async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getRaw();
-      expectElasticsearchGetQuery(server, configGet);
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getRaw(req);
+      expectElasticsearchGetQuery(server, req, configGet);
     });
 
     it(`without user configuration it's equal to the defaults`, async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getRaw();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getRaw(req);
       expect(isEqual(result, defaultsProvider())).to.equal(true);
     });
 
     it(`user configuration gets merged with defaults`, async function () {
       const getResult = { foo: 'bar' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getRaw();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getRaw(req);
       const merged = defaultsProvider();
       merged.foo = { userValue: 'bar' };
       expect(isEqual(result, merged)).to.equal(true);
@@ -184,8 +247,8 @@ describe('ui settings', function () {
 
     it(`user configuration gets merged into defaults`, async function () {
       const getResult = { dateFormat: 'YYYY-MM-DD' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getRaw();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getRaw(req);
       const merged = defaultsProvider();
       merged.dateFormat.userValue = 'YYYY-MM-DD';
       expect(isEqual(result, merged)).to.equal(true);
@@ -195,15 +258,15 @@ describe('ui settings', function () {
   describe('#getAll()', function () {
     it('pulls user configuration from ES', async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getAll();
-      expectElasticsearchGetQuery(server, configGet);
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getAll(req);
+      expectElasticsearchGetQuery(server, req, configGet);
     });
 
     it(`returns key value pairs`, async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getAll();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getAll(req);
       const defaults = defaultsProvider();
       const expectation = {};
       Object.keys(defaults).forEach(key => {
@@ -214,8 +277,8 @@ describe('ui settings', function () {
 
     it(`returns key value pairs including user configuration`, async function () {
       const getResult = { something: 'user-provided' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getAll();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getAll(req);
       const defaults = defaultsProvider();
       const expectation = {};
       Object.keys(defaults).forEach(key => {
@@ -227,8 +290,8 @@ describe('ui settings', function () {
 
     it(`returns key value pairs including user configuration for existing settings`, async function () {
       const getResult = { dateFormat: 'YYYY-MM-DD' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.getAll();
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.getAll(req);
       const defaults = defaultsProvider();
       const expectation = {};
       Object.keys(defaults).forEach(key => {
@@ -242,55 +305,63 @@ describe('ui settings', function () {
   describe('#get()', function () {
     it('pulls user configuration from ES', async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.get();
-      expectElasticsearchGetQuery(server, configGet);
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.get(req);
+      expectElasticsearchGetQuery(server, req, configGet);
     });
 
     it(`returns the promised value for a key`, async function () {
       const getResult = {};
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.get('dateFormat');
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.get(req, 'dateFormat');
       const defaults = defaultsProvider();
       expect(result).to.equal(defaults.dateFormat.value);
     });
 
     it(`returns the user-configured value for a custom key`, async function () {
       const getResult = { custom: 'value' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.get('custom');
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.get(req, 'custom');
       expect(result).to.equal('value');
     });
 
     it(`returns the user-configured value for a modified key`, async function () {
       const getResult = { dateFormat: 'YYYY-MM-DD' };
-      const { server, uiSettings, configGet } = instantiate({ getResult });
-      const result = await uiSettings.get('dateFormat');
+      const { server, uiSettings, configGet, req } = instantiate({ getResult });
+      const result = await uiSettings.get(req, 'dateFormat');
       expect(result).to.equal('YYYY-MM-DD');
     });
   });
 });
 
-function expectElasticsearchGetQuery(server, configGet) {
-  expect(server.plugins.elasticsearch.client.get.callCount).to.equal(1);
-  expect(isEqual(server.plugins.elasticsearch.client.get.firstCall.args, [{
+function expectElasticsearchGetQuery(server, req, configGet) {
+  const { callWithRequest } = server.plugins.elasticsearch;
+  sinon.assert.calledOnce(callWithRequest);
+  const [reqPassed, method, params] = callWithRequest.args[0];
+  expect(reqPassed).to.be(req);
+  expect(method).to.be('get');
+  expect(params).to.eql({
     index: configGet('kibana.index'),
     id: configGet('pkg.version'),
     type: 'config'
-  }])).to.equal(true);
+  });
 }
 
-function expectElasticsearchUpdateQuery(server, configGet, doc) {
-  expect(server.plugins.elasticsearch.client.update.callCount).to.equal(1);
-  expect(isEqual(server.plugins.elasticsearch.client.update.firstCall.args, [{
+function expectElasticsearchUpdateQuery(server, req, configGet, doc) {
+  const { callWithRequest } = server.plugins.elasticsearch;
+  sinon.assert.calledOnce(callWithRequest);
+  const [reqPassed, method, params] = callWithRequest.args[0];
+  expect(reqPassed).to.be(req);
+  expect(method).to.be('update');
+  expect(params).to.eql({
     index: configGet('kibana.index'),
     id: configGet('pkg.version'),
     type: 'config',
     body: { doc }
-  }])).to.equal(true);
+  });
 }
 
-function instantiate({ getResult } = {}) {
+function instantiate({ getResult, callWithRequest } = {}) {
   const esStatus = {
     state: 'green',
     on: sinon.spy()
@@ -308,14 +379,27 @@ function instantiate({ getResult } = {}) {
     },
     ready: sinon.stub().returns(Promise.resolve())
   };
+  const req = { __stubHapiRequest: true, path: '', headers: {} };
   const server = {
     decorate: (_, key, value) => server[key] = value,
     plugins: {
       elasticsearch: {
-        client: {
-          get: sinon.stub().returns(Promise.resolve({ _source: getResult })),
-          update: sinon.stub().returns(Promise.resolve())
-        }
+        errors: esErrors,
+        callWithRequest: sinon.spy((withReq, method, params) => {
+          if (callWithRequest) {
+            return callWithRequest(withReq, method, params);
+          }
+
+          expect(withReq).to.be(req);
+          switch (method) {
+            case 'get':
+              return Promise.resolve({ _source: getResult });
+            case 'update':
+              return Promise.resolve();
+            default:
+              throw new Error(`callWithRequest() is using unexpected method "${method}"`);
+          }
+        })
       }
     }
   };
@@ -328,5 +412,5 @@ function instantiate({ getResult } = {}) {
   };
   const setupSettings = init(kbnServer, server, config);
   const uiSettings = server.uiSettings();
-  return { server, uiSettings, configGet };
+  return { server, uiSettings, configGet, req };
 }
diff --git a/src/ui/settings/index.js b/src/ui/settings/index.js
index d18f7491bc7a1..29f5959d67038 100644
--- a/src/ui/settings/index.js
+++ b/src/ui/settings/index.js
@@ -1,5 +1,6 @@
 import { defaultsDeep, partial } from 'lodash';
 import defaultsProvider from './defaults';
+import Bluebird from 'bluebird';
 
 export default function setupSettings(kbnServer, server, config) {
   const status = kbnServer.status.create('ui settings');
@@ -34,12 +35,14 @@ export default function setupSettings(kbnServer, server, config) {
   server.decorate('server', 'uiSettings', () => uiSettings);
   kbnServer.ready().then(mirrorEsStatus);
 
-  function get(key) {
-    return getAll().then(all => all[key]);
+  async function get(req, key) {
+    assertRequest(req);
+    return getAll(req).then(all => all[key]);
   }
 
-  function getAll() {
-    return getRaw()
+  async function getAll(req) {
+    assertRequest(req);
+    return getRaw(req)
     .then(raw => Object.keys(raw)
       .reduce((all, key) => {
         const item = raw[key];
@@ -50,9 +53,10 @@ export default function setupSettings(kbnServer, server, config) {
     );
   }
 
-  function getRaw() {
+  async function getRaw(req) {
+    assertRequest(req);
     return Promise
-      .all([getDefaults(), getUserProvided()])
+      .all([getDefaults(), getUserProvided(req)])
       .then(([defaults, user]) => defaultsDeep(user, defaults));
   }
 
@@ -60,46 +64,48 @@ export default function setupSettings(kbnServer, server, config) {
     return Promise.resolve(defaultsProvider());
   }
 
-  function userSettingsNotFound(kibanaVersion) {
-    status.red(`Could not find user-provided settings for Kibana ${kibanaVersion}`);
-    return {};
-  }
+  async function getUserProvided(req, { ignore401Errors = false } = {}) {
+    assertRequest(req);
+    const { callWithRequest, errors } = server.plugins.elasticsearch;
+
+    const params = getClientSettings(config);
+    const allowedErrors = [errors[404], errors[403], errors.NoConnections];
+    if (ignore401Errors) allowedErrors.push(errors[401]);
 
-  function getUserProvided() {
-    const { client } = server.plugins.elasticsearch;
-    const clientSettings = getClientSettings(config);
-    return client
-      .get({ ...clientSettings })
-      .then(res => res._source)
-      .catch(partial(userSettingsNotFound, clientSettings.id))
-      .then(user => hydrateUserSettings(user));
+    return Bluebird.resolve(callWithRequest(req, 'get', params, { wrap401Errors: !ignore401Errors }))
+      .catch(...allowedErrors, err => ({}))
+      .then(resp => resp._source || {})
+      .then(source => hydrateUserSettings(source));
   }
 
-  function setMany(changes) {
-    const { client } = server.plugins.elasticsearch;
-    const clientSettings = getClientSettings(config);
-    return client
-      .update({
-        ...clientSettings,
-        body: { doc: changes }
-      })
+  async function setMany(req, changes) {
+    assertRequest(req);
+    const { callWithRequest } = server.plugins.elasticsearch;
+    const clientParams = {
+      ...getClientSettings(config),
+      body: { doc: changes }
+    };
+    return callWithRequest(req, 'update', clientParams)
       .then(() => ({}));
   }
 
-  function set(key, value) {
-    return setMany({ [key]: value });
+  async function set(req, key, value) {
+    assertRequest(req);
+    return setMany(req, { [key]: value });
   }
 
-  function remove(key) {
-    return set(key, null);
+  async function remove(req, key) {
+    assertRequest(req);
+    return set(req, key, null);
   }
 
-  function removeMany(keys) {
+  async function removeMany(req, keys) {
+    assertRequest(req);
     const changes = {};
     keys.forEach(key => {
       changes[key] = null;
     });
-    return setMany(changes);
+    return setMany(req, changes);
   }
 
   function mirrorEsStatus() {
@@ -138,3 +144,13 @@ function getClientSettings(config) {
   const type = 'config';
   return { index, type, id };
 }
+
+function assertRequest(req) {
+  if (
+    typeof req === 'object' &&
+    typeof req.path === 'string' &&
+    typeof req.headers === 'object'
+  ) return;
+
+  throw new TypeError('all uiSettings methods must be passed a hapi.Request object');
+}
diff --git a/test/functional/apps/visualize/_chart_types.js b/test/functional/apps/visualize/_chart_types.js
index 081f1a3b01e66..e62fcee08811a 100644
--- a/test/functional/apps/visualize/_chart_types.js
+++ b/test/functional/apps/visualize/_chart_types.js
@@ -1,9 +1,7 @@
-
 import expect from 'expect.js';
 
 import {
-  bdd,
-  scenarioManager,
+  bdd
 } from '../../../support';
 
 import PageObjects from '../../../support/page_objects';
@@ -19,16 +17,16 @@ bdd.describe('visualize app', function describeIndexTests() {
     bdd.it('should show the correct chart types', function () {
       var expectedChartTypes = [
         'Area chart', 'Data table', 'Line chart', 'Markdown widget',
-        'Metric', 'Pie chart', 'Tile map', 'Timeseries', 'Vertical bar chart'
+        'Metric', 'Pie chart', 'Tag cloud', 'Tile map', 'Timeseries', 'Vertical bar chart'
       ];
       // find all the chart types and make sure there all there
       return PageObjects.visualize.getChartTypes()
-      .then(function testChartTypes(chartTypes) {
-        PageObjects.common.debug('returned chart types = ' + chartTypes);
-        PageObjects.common.debug('expected chart types = ' + expectedChartTypes);
-        PageObjects.common.saveScreenshot('Visualize-chart-types');
-        expect(chartTypes).to.eql(expectedChartTypes);
-      });
+        .then(function testChartTypes(chartTypes) {
+          PageObjects.common.debug('returned chart types = ' + chartTypes);
+          PageObjects.common.debug('expected chart types = ' + expectedChartTypes);
+          PageObjects.common.saveScreenshot('Visualize-chart-types');
+          expect(chartTypes).to.eql(expectedChartTypes);
+        });
     });
   });
 });