Merge lp:~michihenning/unity-scopes-api/cache-results into lp:unity-scopes-api

[Michi Henning]

Added result cache that stores the results of the last successful surfacing query. The scope, if it detects connectivity problems, can call reply->push_surfacing_results_from_cache(). This answers the query from the cache, provided that the query is indeed a surfacing query. Otherwise, the method does nothing.

Added result cache that stores the results of the last successful surfacing query. The scope, if it detects connectivity problems, can call reply->push_surfacing_results_from_cache(). This answers the query from the cache, provided that the query is indeed a surfacing query. Otherwise, the method does nothing.

Note: I have not yet updated RELEASE_NOTES, changelog, and minor version number. Still waiting on a decision about ABI breaks. Once that is sorted out, I'll push changes accordingly. For now, I want to see what Jenkins has to say.

[lp:~michihenning/unity-scopes-api/cache-results]

573. By Michi Henning on 2015-01-15

Bumped micro version and updated release notes and changelog.

574. By Michi Henning on 2015-01-15

Merged dependent branch.

575. By Michi Henning on 2015-01-15

Fixed RuntimeConfig test again because it failed under bzr bd.

576. By Michi Henning on 2015-01-20

Merged trunk and resolved conflicts.

577. By Michi Henning on 2015-02-04

Merged trunk.

578. By Michi Henning on 2015-02-04

Simplified CategorisedResult instantiation when pushing from cache.

579. By Michi Henning on 2015-02-05

Added filters and filter_state to cached results and added corresponding tests.

580. By Michi Henning on 2015-02-12

Moved push_surfacing_results_from_cache to end of virtual functions to
avoid ABI break.

581. By Michi Henning on 2015-02-12

Merged trunk and resolved conflicts.

582. By Michi Henning on 2015-02-13

Update micro version, changelog, and release notes.

583. By Michi Henning on 2015-02-13

Fixed changelog. (Thanks Pawel!)

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-12-09 15:26:12 +0000
+++ CMakeLists.txt	2015-01-13 07:11:02 +0000
@@ -193,12 +193,6 @@
     message(FATAL_ERROR "Invalid SANITIZER setting: ${SANITIZER}")
 endif()
 
-option(IPC_MONITORING "Enable IPC traffic monitoring")
-
-if(IPC_MONITORING)
-    add_definitions(-DENABLE_IPC_MONITOR)
-endif()
-
 # Scopes library name. Also used as a prefix in various places, and as a subdirectory
 # name for installed files. Changing this will also require corresponding changes
 # to the debian files.

=== modified file 'CONFIGFILES'
--- CONFIGFILES	2014-12-03 08:05:20 +0000
+++ CONFIGFILES	2015-01-13 07:11:02 +0000
@@ -123,7 +123,15 @@
 
 - ConfigDir
 
-  The parent directory under which the runtime writes the scope configration files.
+  The parent directory under which the run time writes the scope configration files.
+
+  The default value is $HOME/.cache/unity-scopes.
+
+- LogDir
+
+  The parent directory under which the run time writes the scope configration files.
+  Setting this value explicitly to the empty string disables file logging and forces
+  all log entries to go to stderr.
 
   The default value is $HOME/.config/unity-scopes.
 
@@ -132,6 +140,34 @@
 
   $HOME/.config/unity-scopes/<scope_id>/settings.ini
 
+  The environment variable UNITY_SCOPES_LOGDIR overrides this key.
+  Setting this variable explicitly to the empty string disables file logging and forces
+  all log entries to go to stderr.
+
+- Log.MaxFileSize
+
+  The maximum size in bytes of an individual log file before it is rolled over.
+  The value must be at least 1024. The default value is 512 kB.
+
+- Log.MaxDirSize
+
+  The maximum size in bytes of the sum of sizes of all log files in the log directory
+  before they are deleted. The value must be greater than Log.MaxFileSize.
+  The default value is 10 MB.
+
+- Log.TraceChannels
+
+  The names of channels for which to emit trace. This must be a semicolon-separated
+  list of channel names. By default, tracing for all channels is disabled.
+  Valid channel names are:
+
+  - IPC
+
+    Trace inter-process messages activity.
+
+  The environment variable UNITY_SCOPES_LOG_TRACECHANNELS overrides this key.
+  The value must be a semicolon-separate list of channel names.
+
 
 Zmq.ini
 -------
@@ -371,7 +407,7 @@
   A custom scoperunner command-line to be executed when the scope is invoked.
   The following placeholders can be used to substitute config paths where required:
 
-  - %R - absolute path to the runtime .ini config file
+  - %R - absolute path to the run time .ini config file
   - %S - absolute path to the scope's .ini config file
 
   E.g. "ScopeRunner = /usr/bin/gdb --ex run --args /usr/lib/x86_64-linux-gnu/unity-scopes/scoperunner %R %S"

=== modified file 'HACKING'
--- HACKING	2014-10-09 02:52:15 +0000
+++ HACKING	2015-01-13 07:11:02 +0000
@@ -190,33 +190,6 @@
 
 The report provides a nicely layed-out page with all the details.
 
-Debugging IPC
--------------
-
-There are lots of messages being passed between the various scope processes,
-and therefore it might be sometimes useful to see those to help with debugging.
-There is a special monitoring code that is enabled if you pass
--DIPC_MONITORING=ON to cmake. When you build the library with this code,
-the messages can be introspected using the python scripts in the tools directory.
-
-Note that the tools require python dependencies that are otherwise not required
-for regular builds, to get those, grab python-zmq and python-capnproto.
-
-As of time of writing this, python-capnproto is not present in the distro,
-so get it from https://github.com/jparyani/pycapnp.git, also note that the master
-branch is compatible with capnproto 0.3, not 0.4 which we're using, so you need
-to switch to the "feature/v0.4" branch.
-
-Once you have the extra python dependencies you need to run:
-
-    $ ./zmq-monitor-host.py &
-
-This runs a monitor proxy that forwards the monitored messages from all publishers
-to all subscribers.
-Then you can run a subscriber that will display content of the messages:
-
-    $ ./zmq-parser.py
-
 Autopkg test suite
 ------------------
 

=== modified file 'debian/libunity-scopes3.symbols'
--- debian/libunity-scopes3.symbols	2014-12-10 12:59:46 +0000
+++ debian/libunity-scopes3.symbols	2015-01-13 07:11:02 +0000
@@ -403,8 +403,12 @@
  (c++)"unity::scopes::internal::RuntimeConfig::default_app_directory()@Base" 0.6.9+15.04.20141129
  (c++)"unity::scopes::internal::RuntimeConfig::default_cache_directory()@Base" 0.6.9+15.04.20141129
  (c++)"unity::scopes::internal::RuntimeConfig::default_config_directory()@Base" 0.6.2+rtm+rtm+rtm+14.09.20140818
+ (c++)"unity::scopes::internal::RuntimeConfig::default_log_directory()@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeConfig::default_middleware_configfile() const@Base" 0.4.2+14.04.20140404.2
  (c++)"unity::scopes::internal::RuntimeConfig::default_middleware() const@Base" 0.4.2+14.04.20140404.2
+ (c++)"unity::scopes::internal::RuntimeConfig::log_directory() const@Base" 0replaceme
+ (c++)"unity::scopes::internal::RuntimeConfig::max_log_dir_size() const@Base" 0replaceme
+ (c++)"unity::scopes::internal::RuntimeConfig::max_log_file_size() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeConfig::reap_expiry() const@Base" 0.4.5+14.10.20140513
  (c++)"unity::scopes::internal::RuntimeConfig::reap_interval() const@Base" 0.4.5+14.10.20140513
  (c++)"unity::scopes::internal::RuntimeConfig::registry_configfile() const@Base" 0.4.2+14.04.20140404.2
@@ -413,7 +417,9 @@
  (c++)"unity::scopes::internal::RuntimeConfig::RuntimeConfig(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.2+14.04.20140404.2
  (c++)"unity::scopes::internal::RuntimeConfig::ss_configfile() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeConfig::ss_registry_identity() const@Base" 0.4.4+14.10.20140508
+ (c++)"unity::scopes::internal::RuntimeConfig::trace_channels() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::async_pool() const@Base" 0.4.3+14.10.20140428
+ (c++)"unity::scopes::internal::RuntimeImpl::cache_directory() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::confined() const@Base" 0.6.8+15.04.20141119
  (c++)"unity::scopes::internal::RuntimeImpl::confinement_type() const@Base" 0.6.8+15.04.20141119
  (c++)"unity::scopes::internal::RuntimeImpl::create(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
@@ -425,6 +431,7 @@
  (c++)"unity::scopes::internal::RuntimeImpl::find_tmp_dir() const@Base" 0.6.8+15.04.20141119
  (c++)"unity::scopes::internal::RuntimeImpl::future_queue() const@Base" 0.4.3+14.10.20140428
  (c++)"unity::scopes::internal::RuntimeImpl::logger() const@Base" 0.6.10+15.04.20141210.2
+ (c++)"unity::scopes::internal::RuntimeImpl::logger(unity::scopes::internal::Logger::Channel) const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::proxy_to_string(std::shared_ptr<unity::scopes::Object> const&) const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RuntimeImpl::registry_configfile() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::RuntimeImpl::registry() const@Base" 0.4.0+14.04.20140312.1
@@ -437,6 +444,7 @@
  (c++)"unity::scopes::internal::RuntimeImpl::ss_configfile() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeImpl::ss_registry_identity() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::RuntimeImpl::string_to_proxy(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::RuntimeImpl::tmp_directory() const@Base" 0replaceme
  (c++)"unity::scopes::internal::RuntimeImpl::waiter_thread(std::shared_ptr<unity::scopes::internal::ThreadSafeQueue<std::future<void> > > const&) const@Base" 0.4.3+14.10.20140428
  (c++)"unity::scopes::internal::safe_strerror(int)@Base" 0.6.9+15.04.20141129
  (c++)"unity::scopes::internal::ScopeConfig::appearance_attributes() const@Base" 0.4.2+14.04.20140404.2
@@ -462,12 +470,12 @@
  (c++)"unity::scopes::internal::ScopeConfig::search_hint() const@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeConfig::version() const@Base" 0.6.9+15.04.20141129
  (c++)"unity::scopes::internal::ScopeImpl::activate(unity::scopes::Result const&, unity::scopes::ActionMetadata const&, std::shared_ptr<unity::scopes::ActivationListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
- (c++)"unity::scopes::internal::ScopeImpl::create(std::shared_ptr<unity::scopes::internal::MWScope> const&, unity::scopes::internal::RuntimeImpl*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::ScopeImpl::create(std::shared_ptr<unity::scopes::internal::MWScope> const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0replaceme
  (c++)"unity::scopes::internal::ScopeImpl::fwd()@Base" 0.4.3+14.10.20140428
  (c++)"unity::scopes::internal::ScopeImpl::perform_action(unity::scopes::Result const&, unity::scopes::ActionMetadata const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::shared_ptr<unity::scopes::ActivationListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeImpl::preview(unity::scopes::Result const&, unity::scopes::ActionMetadata const&, std::shared_ptr<unity::scopes::PreviewListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeImpl::~ScopeImpl()@Base" 0.4.0+14.04.20140312.1
- (c++)"unity::scopes::internal::ScopeImpl::ScopeImpl(std::shared_ptr<unity::scopes::internal::MWScope> const&, unity::scopes::internal::RuntimeImpl*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.4.0+14.04.20140312.1
+ (c++)"unity::scopes::internal::ScopeImpl::ScopeImpl(std::shared_ptr<unity::scopes::internal::MWScope> const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0replaceme
  (c++)"unity::scopes::internal::ScopeImpl::search(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unity::scopes::FilterState const&, unity::scopes::SearchMetadata const&, std::shared_ptr<unity::scopes::SearchListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeImpl::search(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unity::scopes::FilterState const&, unity::scopes::SearchMetadata const&, std::shared_ptr<unity::scopes::SearchListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeImpl::search(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unity::scopes::SearchMetadata const&, std::shared_ptr<unity::scopes::SearchListenerBase> const&)@Base" 0.4.0+14.04.20140312.1
@@ -532,7 +540,7 @@
  (c++)"unity::scopes::internal::ScopeObject::preview(unity::scopes::Result const&, unity::scopes::ActionMetadata const&, std::shared_ptr<unity::scopes::internal::MWReply> const&, unity::scopes::internal::InvokeInfo const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeObject::query(std::shared_ptr<unity::scopes::internal::MWReply> const&, unity::scopes::internal::MiddlewareBase*, std::function<std::shared_ptr<unity::scopes::QueryBase> ()> const&, std::function<std::shared_ptr<unity::scopes::internal::QueryObjectBase> (std::shared_ptr<unity::scopes::QueryBase>, std::shared_ptr<unity::scopes::internal::MWQueryCtrl>)> const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::ScopeObject::~ScopeObject()@Base" 0.4.0+14.04.20140312.1
- (c++)"unity::scopes::internal::ScopeObject::ScopeObject(unity::scopes::internal::RuntimeImpl*, unity::scopes::ScopeBase*, bool)@Base" 0.6.2+rtm+rtm+rtm+14.09.20140818
+ (c++)"unity::scopes::internal::ScopeObject::ScopeObject(unity::scopes::ScopeBase*, bool)@Base" 0replaceme
  (c++)"unity::scopes::internal::ScopeObject::search(unity::scopes::CannedQuery const&, unity::scopes::SearchMetadata const&, std::shared_ptr<unity::scopes::internal::MWReply> const&, unity::scopes::internal::InvokeInfo const&)@Base" 0.4.0+14.04.20140312.1
  (c++)"unity::scopes::internal::smartscopes::SSConfig::http_reply_timeout() const@Base" 0.4.4+14.10.20140508
  (c++)"unity::scopes::internal::smartscopes::SSConfig::reg_refresh_fail_timeout() const@Base" 0.4.4+14.10.20140508

=== modified file 'doc/Doxyfile-devel.in'
--- doc/Doxyfile-devel.in	2014-06-16 03:26:21 +0000
+++ doc/Doxyfile-devel.in	2015-01-13 07:11:02 +0000
@@ -1758,7 +1758,7 @@
 # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
 # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
 
-DOT_GRAPH_MAX_NODES    = 50
+DOT_GRAPH_MAX_NODES    = 100
 
 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
 # graphs generated by dot. A depth value of 3 means that only nodes reachable

=== modified file 'doc/tutorial.dox'
--- doc/tutorial.dox	2014-12-10 10:15:55 +0000
+++ doc/tutorial.dox	2015-01-13 07:11:02 +0000
@@ -229,6 +229,19 @@
 here (if at all possible), so the user gets to see at least some results (instead of being confronted with
 a blank screen).
 
+The runtime automatically saves the results of the most recent surfacing query. If a scope cannot produce
+a result for a surfacing query (presumably, due to connectivity problems), calling
+\link unity::scopes::SearchReply::push_surfacing_results_from_cache() push_surfacing_results_from_cache()\endlink
+pushes the results that were produced by the most recent successful
+surfacing query from the cache. If your scope cannot produce surfacing results, you can call this
+method to "replay" the results of the previous surfacing query. In turn, this avoids the user
+being presented with an empty screen if he/she swipes to the scope while the device does not have connectivity.
+
+`push_surfacing_results_from_cache()` has an effect only if called for a surfacing query (that is, a query with an empty query string). If called for a non-empty query, it does nothing.
+
+You must call this method before calling \link unity::scopes::Reply::finished finished()\endlink,
+otherwise no cached results will be pushed. (`push_surfacing_results_from_cache() implicitly calls `finished()`);
+
 \paragraph querybase Implementing QueryBase
 
 You must implement a class that derives from \link unity::scopes::SearchQueryBase SearchQueryBase\endlink and return

=== modified file 'include/unity/scopes/CategorisedResult.h'
--- include/unity/scopes/CategorisedResult.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/CategorisedResult.h	2015-01-13 07:11:02 +0000
@@ -31,6 +31,7 @@
 {
     class CategorisedResultImpl;
     class ResultReplyObject;
+    class SearchReplyImpl;
 }
 
 /**
@@ -80,6 +81,7 @@
 
     friend class internal::CategorisedResultImpl;
     friend class internal::ResultReplyObject;
+    friend class internal::SearchReplyImpl;
 };
 
 } // namespace scopes

=== modified file 'include/unity/scopes/Category.h'
--- include/unity/scopes/Category.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/Category.h	2015-01-13 07:11:02 +0000
@@ -36,6 +36,7 @@
 {
     class CategoryImpl;
     class CategoryRegistry;
+    class SearchReplyImpl;
 }
 
 /**
@@ -100,6 +101,7 @@
     /// @endcond
 
     friend class internal::CategoryRegistry;
+    friend class internal::SearchReplyImpl;
 
 private:
     std::unique_ptr<internal::CategoryImpl> p;

=== modified file 'include/unity/scopes/SearchReply.h'
--- include/unity/scopes/SearchReply.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/SearchReply.h	2015-01-13 07:11:02 +0000
@@ -141,6 +141,27 @@
     virtual bool push(Filters const& filters, FilterState const& filter_state) = 0;
 
     /**
+    \brief Push the results that were produced by the most recent surfacing query.
+
+    The runtime automatically saves the results of the most recent surfacing query.
+    If a scope cannot produce a result for a surfacing query (presumably, due to
+    connectivity problems), calling push_surfacing_results_from_cache() pushes
+    the results that were produced by the most recent successful surfacing query
+    from the cache. If a scope cannot produce surfacing results, it can call this
+    method to "replay" the previous results. In turn, this avoids the user being
+    presented with an empty screen if he/she swipes to the scope while the device
+    does not have connectivity.
+
+    This method has an effect only if called for a surfacing query (that is, a
+    query with an empty query string). If called for a non-empty query, it does
+    nothing.
+
+    You must call this method before calling finished(), otherwise no cached results
+    will be pushed (push_surfacing_results_from_cache() implicitly calls finished()).
+    */
+    virtual void push_surfacing_results_from_cache() = 0;
+
+    /**
     \brief Destroys a Reply.
 
     If a Reply goes out of scope without a prior call to finished(), the destructor implicitly calls finished().

=== added file 'include/unity/scopes/internal/''
--- include/unity/scopes/internal/'	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/internal/'	2015-01-13 07:11:02 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/scopes/internal/MWRegistryProxyFwd.h>
+#include <unity/scopes/internal/ObjectImpl.h>
+#include <unity/scopes/Registry.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+class RegistryImpl : public virtual unity::scopes::Registry, public virtual ObjectImpl
+{
+public:
+    RegistryImpl(MWRegistryProxy const& mw_proxy);
+    ~RegistryImpl();
+
+    virtual ScopeMetadata get_metadata(std::string const& scope_id) override;
+    virtual MetadataMap list() override;
+    virtual MetadataMap list_if(std::function<bool(ScopeMetadata const& item)> predicate) override;
+    virtual bool is_scope_running(std::string const& scope_id) override;
+
+    virtual core::ScopedConnection set_scope_state_callback(std::string const& scope_id, std::function<void(bool)> callback) override;
+    virtual core::ScopedConnection set_list_update_callback(std::function<void()> callback) override;
+
+    // Remote operation. Not part of public API, hence not override.
+    ObjectProxy locate(std::string const& identity);
+
+private:
+    MWRegistryProxy fwd();
+};
+
+} // namespace internal
+
+} // namespace scopes
+
+} // namespace unity

=== modified file 'include/unity/scopes/internal/ActivationQueryObject.h'
--- include/unity/scopes/internal/ActivationQueryObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/ActivationQueryObject.h	2015-01-13 07:11:02 +0000
@@ -38,8 +38,7 @@
 
     ActivationQueryObject(std::shared_ptr<ActivationQueryBase> const& act_base,
                           MWReplyProxy const& reply,
-                          MWQueryCtrlProxy const& ctrl,
-                          boost::log::sources::severity_channel_logger_mt<>& logger);
+                          MWQueryCtrlProxy const& ctrl);
     virtual ~ActivationQueryObject();
     virtual void run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept override;
 

=== modified file 'include/unity/scopes/internal/CategoryRegistry.h'
--- include/unity/scopes/internal/CategoryRegistry.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/CategoryRegistry.h	2015-01-13 07:11:02 +0000
@@ -46,13 +46,15 @@
     CategoryRegistry() = default;
 
     /**
-    \brief Deserializes category from a variant_map and registers it. Throws if category with same id exists.
+    \brief Deserializes category from a variant_map and registers it.
+    \throws unity::InvalidArgumentException if a category with the same id exists already.
     \return category instance
     */
     Category::SCPtr register_category(VariantMap const& variant_map);
 
     /**
-    \brief Creates category from supplied parameters. Throws if category with same id exists.
+    \brief Creates category from supplied parameters.
+    \throws unity::InvalidArgumentException if a category with the same id exists already.
     \return category instance
     */
     Category::SCPtr register_category(std::string const& id, std::string const& title, std::string const& icon, CannedQuery::SCPtr const& query, CategoryRenderer const& renderer_template);
@@ -65,13 +67,20 @@
 
     /**
     \brief Register an existing category instance with this registry.
-    Throws if category with sane id exists.
+    \throws unity::InvalidArgumentException if a category with the same id exists already.
     */
     void register_category(Category::SCPtr category);
 
+    /**
+    \brief Serializes all categories in the registry.
+    \return VariantArray containing all categories.
+    */
+    VariantArray serialize() const;
+
 private:
     mutable std::mutex mutex_;
-    std::map<std::string, Category::SCPtr> categories_;
+    typedef std::pair<std::string, Category::SCPtr> CatPair;
+    std::vector<CatPair> categories_;                         // vector instead of map, so we preserve order
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/DfltConfig.h.in'
--- include/unity/scopes/internal/DfltConfig.h.in	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/DfltConfig.h.in	2015-01-13 07:11:02 +0000
@@ -46,12 +46,20 @@
 
 static constexpr char const* DFLT_SS_SCOPE_IDENTITY = "SmartScope";
 
-static const int DFLT_REAP_EXPIRY = 45;              // seconds
-static const int DFLT_REAP_INTERVAL = 10;            // seconds
-static const int DFLT_PROCESS_TIMEOUT = 4000;        // milliseconds
-static const int DFLT_ZMQ_TWOWAY_TIMEOUT = 500;      // milliseconds
-static const int DFLT_ZMQ_LOCATE_TIMEOUT = 5000;     // milliseconds
-static const int DFLT_ZMQ_REGISTRY_TIMEOUT = 5000;   // milliseconds
+static constexpr int DFLT_REAP_EXPIRY = 45;              // seconds
+static constexpr int DFLT_REAP_INTERVAL = 10;            // seconds
+static constexpr int DFLT_PROCESS_TIMEOUT = 4000;        // milliseconds
+static constexpr int DFLT_ZMQ_TWOWAY_TIMEOUT = 500;      // milliseconds
+static constexpr int DFLT_ZMQ_LOCATE_TIMEOUT = 5000;     // milliseconds
+static constexpr int DFLT_ZMQ_REGISTRY_TIMEOUT = 5000;   // milliseconds
+
+static constexpr char const* DFLT_HOME_CACHE_SUBDIR = ".local/share/unity-scopes";
+static constexpr char const* DFLT_HOME_APP_SUBDIR = ".local/share";
+static constexpr char const* DFLT_HOME_CONFIG_SUBDIR = ".config/unity-scopes";
+static constexpr char const* DFLT_HOME_LOG_SUBDIR = ".cache/unity-scopes/logs";
+
+static constexpr int DFLT_MAX_LOG_FILE_SIZE = 512 * 1024;       // bytes, individual file size
+static constexpr int DFLT_MAX_LOG_DIR_SIZE = 10 * 1024 * 1024;  // bytes, sum of file sizes
 
 } // namespace internal
 

=== modified file 'include/unity/scopes/internal/Logger.h'
--- include/unity/scopes/internal/Logger.h	2014-11-25 23:31:51 +0000
+++ include/unity/scopes/internal/Logger.h	2015-01-13 07:11:02 +0000
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <unity/util/DefinesPtrs.h>
+#include <unity/util/NonCopyable.h>
 #include <unity/util/ResourcePtr.h>
 
 #define BOOST_LOG_DYN_LINK
@@ -27,6 +28,10 @@
 #include <boost/log/sources/global_logger_storage.hpp>
 #include <boost/log/sources/record_ostream.hpp>
 #include <boost/log/sources/severity_channel_logger.hpp>
+#include <boost/log/utility/value_ref.hpp>
+
+#include <atomic>
+#include <unordered_map>
 
 namespace unity
 {
@@ -37,35 +42,76 @@
 namespace internal
 {
 
+namespace
+{
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+
+BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", int)
+BOOST_LOG_ATTRIBUTE_KEYWORD(channel, "Channel", std::string)
+
+#pragma GCC diagnostic pop
+
+}
+
 class Logger
 {
 public:
+    NONCOPYABLE(Logger);
     UNITY_DEFINES_PTRS(Logger);
 
     // Instantiate a logger that logs to std::clog.
     Logger(std::string const& id);
     ~Logger();
 
+    enum Channel
+    {
+        IPC,
+        LastChannelEnum_
+    };
+
+    // Returns default logger (no channel)
     operator boost::log::sources::severity_channel_logger_mt<>&();
 
-    void set_log_file(std::string const& path);
-
-    enum Severity { Trace, Info, Warning, Error, Fatal };
+    // Returns logger for specified channel.
+    boost::log::sources::severity_channel_logger_mt<>& operator()(Channel c);
+
+    void set_log_file(std::string const& path, int rotation_size, int dir_size);
+
+    enum Severity { Info, Warning, Error, Fatal, Trace };
     Severity set_severity_threshold(Severity s);
 
+    bool set_channel(Channel c, bool enable);
+    bool set_channel(std::string channel_name, bool enable);
+    void enable_channels(std::vector<std::string> const& names);
+
 private:
-    std::string scope_id_;
-    boost::log::sources::severity_channel_logger_mt<> logger_;
-
-    typedef boost::log::sinks::synchronous_sink<boost::log::sinks::text_ostream_backend> ClogSinkT;
+    bool filter(boost::log::value_ref<int, tag::severity> const& level,
+                boost::log::value_ref<std::string, tag::channel> const& channel);
+
+    void formatter(boost::log::record_view const& rec,
+                   boost::log::formatting_ostream& strm);
+
+    std::string scope_id_;  // immutable
+
+    boost::log::sources::severity_channel_logger_mt<> logger_;  // Default logger, no channel, immutable
+
+    std::atomic<Severity> severity_;
+
+    typedef boost::log::sinks::asynchronous_sink<boost::log::sinks::text_ostream_backend> ClogSinkT;
     typedef boost::shared_ptr<ClogSinkT> ClogSinkPtr;
     ClogSinkPtr clog_sink_;
 
-    typedef boost::log::sinks::synchronous_sink<boost::log::sinks::text_file_backend> FileSinkT;
+    typedef boost::log::sinks::asynchronous_sink<boost::log::sinks::text_file_backend> FileSinkT;
     typedef boost::shared_ptr<FileSinkT> FileSinkPtr;
     FileSinkPtr file_sink_;
 
-    Severity severity_;
+    typedef std::pair<boost::log::sources::severity_channel_logger_mt<>, std::atomic_bool> ChannelData;
+    typedef std::unordered_map<std::string, ChannelData> ChannelMap;
+    ChannelMap channel_loggers_;  // immutable
+
+    std::mutex mutex_;  // Protects clog_sink_ and file_sink_
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/ObjectImpl.h'
--- include/unity/scopes/internal/ObjectImpl.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/ObjectImpl.h	2015-01-13 07:11:02 +0000
@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include<unity/scopes/internal/Logger.h>
 #include<unity/scopes/internal/MWObjectProxyFwd.h>
 #include<unity/scopes/Object.h>
 
@@ -36,7 +35,7 @@
 class ObjectImpl : public virtual Object, public virtual std::enable_shared_from_this<ObjectImpl>
 {
 public:
-    ObjectImpl(MWProxy const& mw_proxy, boost::log::sources::severity_channel_logger_mt<>& logger);
+    ObjectImpl(MWProxy const& mw_proxy);
     virtual ~ObjectImpl();
 
     virtual std::string identity() override;
@@ -59,8 +58,6 @@
     MWProxy mw_proxy_;
     std::mutex proxy_mutex_;           // Protects mw_proxy_
 
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
-
 private:
     void check_proxy();                // Throws from operations if mw_proxy_ is null
 };

=== modified file 'include/unity/scopes/internal/PreviewQueryObject.h'
--- include/unity/scopes/internal/PreviewQueryObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/PreviewQueryObject.h	2015-01-13 07:11:02 +0000
@@ -39,8 +39,7 @@
 
     PreviewQueryObject(std::shared_ptr<PreviewQueryBase> const& preview_base,
                        MWReplyProxy const& reply,
-                       MWQueryCtrlProxy const& ctrl,
-                       boost::log::sources::severity_channel_logger_mt<>& logger);
+                       MWQueryCtrlProxy const& ctrl);
     virtual ~PreviewQueryObject();
     void run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept override;
 

=== modified file 'include/unity/scopes/internal/PreviewReplyImpl.h'
--- include/unity/scopes/internal/PreviewReplyImpl.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/PreviewReplyImpl.h	2015-01-13 07:11:02 +0000
@@ -39,8 +39,7 @@
 {
 public:
     PreviewReplyImpl(MWReplyProxy const& mw_proxy,
-                     std::shared_ptr<QueryObjectBase>const & qo,
-                     boost::log::sources::severity_channel_logger_mt<>& logger);
+                     std::shared_ptr<QueryObjectBase>const & qo);
     virtual ~PreviewReplyImpl();
 
     virtual bool register_layout(unity::scopes::ColumnLayoutList const& layouts) override;

=== modified file 'include/unity/scopes/internal/QueryCtrlImpl.h'
--- include/unity/scopes/internal/QueryCtrlImpl.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/QueryCtrlImpl.h	2015-01-13 07:11:02 +0000
@@ -37,9 +37,7 @@
 class QueryCtrlImpl : public virtual unity::scopes::QueryCtrl, public virtual ObjectImpl
 {
 public:
-    QueryCtrlImpl(MWQueryCtrlProxy const& ctrl_proxy,
-                  MWReplyProxy const& reply_proxy,
-                  boost::log::sources::severity_channel_logger_mt<>& logger);
+    QueryCtrlImpl(MWQueryCtrlProxy const& ctrl_proxy, MWReplyProxy const& reply_proxy);
     virtual ~QueryCtrlImpl();
 
     virtual void cancel() override;

=== modified file 'include/unity/scopes/internal/QueryCtrlObjectBase.h'
--- include/unity/scopes/internal/QueryCtrlObjectBase.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/QueryCtrlObjectBase.h	2015-01-13 07:11:02 +0000
@@ -19,7 +19,6 @@
 #pragma once
 
 #include <unity/scopes/internal/AbstractObject.h>
-#include <unity/scopes/internal/InvokeInfo.h>
 
 namespace unity
 {
@@ -30,6 +29,8 @@
 namespace internal
 {
 
+class InvokeInfo;
+
 class QueryCtrlObjectBase : public AbstractObject
 {
 public:

=== modified file 'include/unity/scopes/internal/QueryObject.h'
--- include/unity/scopes/internal/QueryObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/QueryObject.h	2015-01-13 07:11:02 +0000
@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include <unity/scopes/internal/Logger.h>
 #include <unity/scopes/internal/MWReplyProxyFwd.h>
 #include <unity/scopes/internal/MWQueryCtrlProxyFwd.h>
 #include <unity/scopes/internal/QueryObjectBase.h>
@@ -47,13 +46,11 @@
 
     QueryObject(std::shared_ptr<QueryBase> const& query_base,
                 MWReplyProxy const& reply,
-                MWQueryCtrlProxy const& ctrl,
-                boost::log::sources::severity_channel_logger_mt<>&);
+                MWQueryCtrlProxy const& ctrl);
     QueryObject(std::shared_ptr<QueryBase> const& query_base,
                 int cardinality,
                 MWReplyProxy const& reply,
-                MWQueryCtrlProxy const& ctrl,
-                boost::log::sources::severity_channel_logger_mt<>& logger);
+                MWQueryCtrlProxy const& ctrl);
     virtual ~QueryObject();
 
     // Remote operation implementations
@@ -76,7 +73,6 @@
     bool pushable_;
     QueryObjectBase::SPtr self_;
     int cardinality_;
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
     mutable std::mutex mutex_;
 };
 

=== modified file 'include/unity/scopes/internal/QueryObjectBase.h'
--- include/unity/scopes/internal/QueryObjectBase.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/QueryObjectBase.h	2015-01-13 07:11:02 +0000
@@ -19,7 +19,6 @@
 #pragma once
 
 #include <unity/scopes/internal/AbstractObject.h>
-#include <unity/scopes/internal/InvokeInfo.h>
 #include <unity/scopes/internal/MWReplyProxyFwd.h>
 #include <unity/util/DefinesPtrs.h>
 
@@ -32,6 +31,8 @@
 namespace internal
 {
 
+class InvokeInfo;
+
 class QueryObjectBase : public AbstractObject
 {
 public:

=== modified file 'include/unity/scopes/internal/RegistryImpl.h'
--- include/unity/scopes/internal/RegistryImpl.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/RegistryImpl.h	2015-01-13 07:11:02 +0000
@@ -31,12 +31,10 @@
 namespace internal
 {
 
-class RuntimeImpl;
-
 class RegistryImpl : public virtual unity::scopes::Registry, public virtual ObjectImpl
 {
 public:
-    RegistryImpl(MWRegistryProxy const& mw_proxy, RuntimeImpl* runtime);
+    RegistryImpl(MWRegistryProxy const& mw_proxy);
     ~RegistryImpl();
 
     virtual ScopeMetadata get_metadata(std::string const& scope_id) override;

=== modified file 'include/unity/scopes/internal/ReplyImpl.h'
--- include/unity/scopes/internal/ReplyImpl.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/ReplyImpl.h	2015-01-13 07:11:02 +0000
@@ -41,9 +41,7 @@
 class ReplyImpl : public virtual unity::scopes::Reply, public virtual ObjectImpl
 {
 public:
-    ReplyImpl(MWReplyProxy const& mw_proxy,
-              std::shared_ptr<QueryObjectBase>const & qo,
-              boost::log::sources::severity_channel_logger_mt<>& logger);
+    ReplyImpl(MWReplyProxy const& mw_proxy, std::shared_ptr<QueryObjectBase>const & qo);
     virtual ~ReplyImpl();
 
     virtual void finished() override;

=== modified file 'include/unity/scopes/internal/ReplyObject.h'
--- include/unity/scopes/internal/ReplyObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/ReplyObject.h	2015-01-13 07:11:02 +0000
@@ -35,6 +35,7 @@
 namespace internal
 {
 
+class InvokeInfo;
 class RuntimeImpl;
 
 // A ReplyObject sits in between the incoming requests from the middleware layer and the

=== modified file 'include/unity/scopes/internal/RuntimeConfig.h'
--- include/unity/scopes/internal/RuntimeConfig.h	2014-11-13 02:31:13 +0000
+++ include/unity/scopes/internal/RuntimeConfig.h	2015-01-13 07:11:02 +0000
@@ -47,9 +47,15 @@
     std::string cache_directory() const;
     std::string app_directory() const;
     std::string config_directory() const;
+    std::string log_directory() const;
+    int max_log_file_size() const;
+    int max_log_dir_size() const;
+    std::vector<std::string> trace_channels() const;
+
     static std::string default_cache_directory();
     static std::string default_app_directory();
     static std::string default_config_directory();
+    static std::string default_log_directory();
 
 private:
     std::string registry_identity_;
@@ -63,6 +69,10 @@
     std::string cache_directory_;
     std::string app_directory_;
     std::string config_directory_;
+    std::string log_directory_;
+    int max_log_file_size_;
+    int max_log_dir_size_;
+    std::vector<std::string> trace_channels_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/RuntimeImpl.h'
--- include/unity/scopes/internal/RuntimeImpl.h	2014-12-04 04:33:50 +0000
+++ include/unity/scopes/internal/RuntimeImpl.h	2015-01-13 07:11:02 +0000
@@ -54,6 +54,7 @@
     ThreadPool::SPtr async_pool() const;
     ThreadSafeQueue<std::future<void>>::SPtr future_queue() const;
     boost::log::sources::severity_channel_logger_mt<>& logger() const;
+    boost::log::sources::severity_channel_logger_mt<>& logger(Logger::Channel channel) const;
     void run_scope(ScopeBase* scope_base,
                    std::string const& scope_ini_file,
                    std::promise<void> ready_promise = std::promise<void>());
@@ -61,6 +62,9 @@
     ObjectProxy string_to_proxy(std::string const& s) const;
     std::string proxy_to_string(ObjectProxy const& proxy) const;
 
+    std::string cache_directory() const;
+    std::string tmp_directory() const;
+
     ~RuntimeImpl();
 
 private:
@@ -88,7 +92,6 @@
     std::string cache_dir_;
     std::string app_dir_;
     std::string config_dir_;
-    std::string tmp_dir_;
     Logger::UPtr logger_;
     mutable Reaper::SPtr reply_reaper_;
     mutable ThreadPool::SPtr async_pool_;  // Pool of invocation threads for async query creation

=== modified file 'include/unity/scopes/internal/ScopeImpl.h'
--- include/unity/scopes/internal/ScopeImpl.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/ScopeImpl.h	2015-01-13 07:11:02 +0000
@@ -45,7 +45,7 @@
 class ScopeImpl : public virtual unity::scopes::Scope, public virtual ObjectImpl
 {
 public:
-    ScopeImpl(MWScopeProxy const& mw_proxy, RuntimeImpl* runtime, std::string const& scope_id);
+    ScopeImpl(MWScopeProxy const& mw_proxy, std::string const& scope_id);
     virtual ~ScopeImpl();
 
     virtual QueryCtrlProxy search(std::string const& q,
@@ -81,7 +81,7 @@
                                    ActionMetadata const& hints,
                                    PreviewListenerBase::SPtr const& reply) override;
 
-    static ScopeProxy create(MWScopeProxy const& mw_proxy, RuntimeImpl* runtime, std::string const& scope_id);
+    static ScopeProxy create(MWScopeProxy const& mw_proxy, std::string const& scope_id);
 
 private:
     MWScopeProxy fwd();

=== modified file 'include/unity/scopes/internal/ScopeObject.h'
--- include/unity/scopes/internal/ScopeObject.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/ScopeObject.h	2015-01-13 07:11:02 +0000
@@ -40,7 +40,6 @@
 {
 
 class MiddlewareBase;
-class RuntimeImpl;
 
 // A ScopeObject sits in between the incoming requests from the middleware layer and the
 // ScopeBase-derived implementation provided by the scope. It forwards incoming
@@ -51,7 +50,7 @@
 public:
     UNITY_DEFINES_PTRS(ScopeObject);
 
-    ScopeObject(RuntimeImpl* runtime, ScopeBase* scope_base, bool debug_mode = false);
+    ScopeObject(ScopeBase* scope_base, bool debug_mode = false);
     virtual ~ScopeObject();
 
     // Remote operation implementations
@@ -83,7 +82,6 @@
     MWQueryCtrlProxy query(MWReplyProxy const& reply, MiddlewareBase* mw_base,
         std::function<QueryBase::SPtr(void)> const& query_factory_fun,
         std::function<QueryObjectBase::SPtr(QueryBase::SPtr, MWQueryCtrlProxy)> const& query_object_factory_fun);
-    RuntimeImpl* const runtime_;
     ScopeBase* const scope_base_;
     bool const debug_mode_;
 };

=== modified file 'include/unity/scopes/internal/ScopeObjectBase.h'
--- include/unity/scopes/internal/ScopeObjectBase.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/ScopeObjectBase.h	2015-01-13 07:11:02 +0000
@@ -19,7 +19,6 @@
 #pragma once
 
 #include <unity/scopes/internal/AbstractObject.h>
-#include <unity/scopes/internal/InvokeInfo.h>
 #include <unity/scopes/internal/MWQueryCtrlProxyFwd.h>
 #include <unity/scopes/internal/MWReplyProxyFwd.h>
 #include <unity/scopes/Result.h>
@@ -39,6 +38,8 @@
 namespace internal
 {
 
+class InvokeInfo;
+
 class ScopeObjectBase : public AbstractObject
 {
 public:

=== modified file 'include/unity/scopes/internal/SearchReplyImpl.h'
--- include/unity/scopes/internal/SearchReplyImpl.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/SearchReplyImpl.h	2015-01-13 07:11:02 +0000
@@ -53,8 +53,8 @@
     SearchReplyImpl(MWReplyProxy const& mw_proxy,
                     std::shared_ptr<QueryObjectBase>const & qo,
                     int cardinality,
-                    std::string const& current_department_id,
-                    boost::log::sources::severity_channel_logger_mt<>& logger);
+                    std::string const& query_string,
+                    std::string const& current_department_id);
     virtual ~SearchReplyImpl();
 
     virtual void register_departments(Department::SCPtr const& parent) override;
@@ -76,14 +76,25 @@
     virtual bool push(unity::scopes::CategorisedResult const& result) override;
     virtual bool push(unity::scopes::Filters const& filters, unity::scopes::FilterState const& filter_state) override;
 
+    virtual void finished() override;
+
+    virtual void push_surfacing_results_from_cache() noexcept;
+
 private:
     bool push(Category::SCPtr category);
+    void write_cached_results() noexcept;
 
     std::shared_ptr<CategoryRegistry> cat_registry_;
 
     std::atomic_int cardinality_;
     std::atomic_int num_pushes_;
+    std::atomic_bool finished_;
+    std::string query_string_;
     std::string current_department_;
+
+    std::vector<unity::scopes::CategorisedResult> cached_results_;
+    Department::SCPtr cached_departments_;
+    std::mutex mutex_;
 };
 
 } // namespace internal

=== modified file 'include/unity/scopes/internal/smartscopes/SSQueryObject.h'
--- include/unity/scopes/internal/smartscopes/SSQueryObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/smartscopes/SSQueryObject.h	2015-01-13 07:11:02 +0000
@@ -18,7 +18,6 @@
 
 #pragma once
 
-#include <unity/scopes/internal/Logger.h>
 #include <unity/scopes/internal/QueryObjectBase.h>
 #include <unity/scopes/ReplyProxyFwd.h>
 
@@ -68,7 +67,7 @@
 public:
     UNITY_DEFINES_PTRS(SSQueryObject);
 
-    SSQueryObject(boost::log::sources::severity_channel_logger_mt<>& logger);
+    SSQueryObject();
     virtual ~SSQueryObject();
 
     // Remote operation implementations
@@ -98,7 +97,6 @@
     mutable std::mutex queries_mutex_;
 
     std::map<std::string, SSQuery::SPtr> queries_;               // reply ID : query
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
 };
 
 }  // namespace smartscopes

=== modified file 'include/unity/scopes/internal/smartscopes/SSScopeObject.h'
--- include/unity/scopes/internal/smartscopes/SSScopeObject.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/smartscopes/SSScopeObject.h	2015-01-13 07:11:02 +0000
@@ -88,8 +88,6 @@
 
     std::unique_ptr<SmartScope> const smartscope_;
     SSRegistryObject::SPtr ss_registry_;
-
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
 };
 
 }  // namespace smartscopes

=== modified file 'include/unity/scopes/internal/smartscopes/SmartScopesClient.h'
--- include/unity/scopes/internal/smartscopes/SmartScopesClient.h	2014-12-09 11:34:26 +0000
+++ include/unity/scopes/internal/smartscopes/SmartScopesClient.h	2015-01-13 07:11:02 +0000
@@ -20,9 +20,9 @@
 
 #include <unity/scopes/FilterBase.h>
 #include <unity/scopes/FilterState.h>
-#include <unity/scopes/internal/smartscopes/HttpClientInterface.h>
 #include <unity/scopes/internal/JsonNodeInterface.h>
 #include <unity/scopes/internal/Logger.h>
+#include <unity/scopes/internal/smartscopes/HttpClientInterface.h>
 #include <unity/scopes/internal/UniqueID.h>
 
 #include <unity/util/NonCopyable.h>
@@ -43,6 +43,8 @@
 namespace internal
 {
 
+class RuntimeImpl;
+
 namespace smartscopes
 {
 
@@ -166,7 +168,7 @@
 
     SmartScopesClient(HttpClientInterface::SPtr http_client,
                       JsonNodeInterface::SPtr json_node,
-                      boost::log::sources::severity_channel_logger_mt<>& logger_,
+                      RuntimeImpl* runtime,
                       std::string const& url = "", // detect url
                       std::string const& partner_id_path = "");
 
@@ -227,6 +229,7 @@
 
     HttpClientInterface::SPtr http_client_;
     JsonNodeInterface::SPtr json_node_;
+    RuntimeImpl* runtime_;
     boost::log::sources::severity_channel_logger_mt<>& logger_;
     std::string url_;
 

=== modified file 'include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h'
--- include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h	2014-11-20 05:32:53 +0000
+++ include/unity/scopes/internal/zmq_middleware/ObjectAdapter.h	2015-01-13 07:11:02 +0000
@@ -19,6 +19,7 @@
 #pragma once
 
 #include <unity/scopes/internal/Logger.h>
+#include <unity/scopes/internal/zmq_middleware/Current.h>
 #include <unity/scopes/internal/zmq_middleware/ZmqObjectProxy.h>
 #include <unity/scopes/ScopeExceptions.h>
 #include <unity/util/NonCopyable.h>
@@ -108,6 +109,12 @@
 
     void store_exception(scopes::MiddlewareException& ex);
 
+    boost::log::sources::severity_channel_logger_mt<>& logger() const;
+    boost::log::sources::severity_channel_logger_mt<>& ipc_logger() const;
+
+    void trace_dispatch(Current const& c);
+    void trace_response();
+
     ZmqMiddleware& mw_;
     std::string name_;
     std::string endpoint_;
@@ -124,8 +131,6 @@
     std::condition_variable state_changed_;
     mutable std::mutex state_mutex_;
 
-    boost::log::sources::severity_channel_logger_mt<>& logger_;
-
     // Map of object identity and servant pairs
     typedef std::unordered_map<std::string, std::shared_ptr<ServantBase>> ServantMap;
     ServantMap servants_;

=== modified file 'include/unity/scopes/internal/zmq_middleware/ZmqException.h'
--- include/unity/scopes/internal/zmq_middleware/ZmqException.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/zmq_middleware/ZmqException.h	2015-01-13 07:11:02 +0000
@@ -48,7 +48,10 @@
 kj::ArrayPtr<kj::ArrayPtr<capnp::word const> const> create_object_not_exist_response(capnp::MessageBuilder& b,
                                                                                      Current const& c);
 
-void throw_if_runtime_exception(capnproto::Response::Reader const& reader);
+void throw_if_runtime_exception(capnproto::Response::Reader const& response);
+
+std::string decode_runtime_exception(capnproto::Response::Reader const& response);
+std::string decode_status(capnproto::Response::Reader const& response);
 
 } // namespace zmq_middleware
 

=== modified file 'include/unity/scopes/internal/zmq_middleware/ZmqObjectProxy.h'
--- include/unity/scopes/internal/zmq_middleware/ZmqObjectProxy.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/zmq_middleware/ZmqObjectProxy.h	2015-01-13 07:11:02 +0000
@@ -72,7 +72,7 @@
 protected:
     capnproto::Request::Builder make_request_(capnp::MessageBuilder& b, std::string const& operation_name) const;
 
-    void invoke_oneway_(capnp::MessageBuilder& out_params);
+    void invoke_oneway_(capnp::MessageBuilder& in_params);
 
     // Holds both the receiver for the unmarshaling buffer (which allocates memory)
     // and the reader that decodes the memory from the unmarshaling buffer.
@@ -89,13 +89,19 @@
         std::unique_ptr<capnp::SegmentArrayMessageReader> reader;
     };
 
-    TwowayOutParams invoke_twoway_(capnp::MessageBuilder& in_params);
-    TwowayOutParams invoke_twoway_(capnp::MessageBuilder& in_params,
+    TwowayOutParams invoke_twoway_(capnp::MessageBuilder& request);
+    TwowayOutParams invoke_twoway_(capnp::MessageBuilder& request,
                                    int64_t twoway_timeout,
                                    int64_t locate_timeout = -1);
 
 private:
-    TwowayOutParams invoke_twoway__(capnp::MessageBuilder& in_params, int64_t timeout);
+    TwowayOutParams invoke_twoway__(capnp::MessageBuilder& request, int64_t timeout);
+
+    std::string decode_request_(capnp::MessageBuilder& request);
+    void trace_request_(capnp::MessageBuilder& request);
+
+    std::string decode_reply_(capnp::MessageBuilder& request, capnp::MessageReader& reply);
+    void trace_reply_(capnp::MessageBuilder& request, capnp::MessageReader& reply);
 
     std::string endpoint_;
     std::string identity_;

=== modified file 'include/unity/scopes/testing/MockSearchReply.h'
--- include/unity/scopes/testing/MockSearchReply.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/testing/MockSearchReply.h	2015-01-13 07:11:02 +0000
@@ -65,6 +65,7 @@
     MOCK_METHOD1(push, bool(CategorisedResult const&));
     MOCK_METHOD2(push, bool(Filters const&, FilterState const&));
     MOCK_METHOD1(push, bool(experimental::Annotation const& annotation));
+    MOCK_METHOD0(push_surfacing_results_from_cache, void());
 };
 
 /// @endcond

=== modified file 'include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h'
--- include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h	2014-12-01 01:51:38 +0000
+++ include/unity/scopes/utility/internal/BufferedSearchReplyImpl.h	2015-01-13 07:11:02 +0000
@@ -18,13 +18,14 @@
 
 #pragma once
 
+#include <unity/scopes/CategorisedResult.h>
 #include <unity/scopes/SearchReply.h>
 #include <unity/scopes/SearchReplyProxyFwd.h>
-#include <unity/scopes/CategorisedResult.h>
+
+#include <atomic>
 #include <memory>
+#include <mutex>
 #include <vector>
-#include <mutex>
-#include <atomic>
 
 namespace unity
 {
@@ -62,6 +63,8 @@
     bool push(unity::scopes::CategorisedResult const& result) override;
     bool push(unity::scopes::Filters const& filters, unity::scopes::FilterState const& filter_state) override;
 
+    void push_surfacing_results_from_cache() override;
+
     // Reply interface
     void finished() override;
     void error(std::exception_ptr ex) override;

=== modified file 'scoperegistry/DirWatcher.cpp'
--- scoperegistry/DirWatcher.cpp	2014-12-02 04:18:44 +0000
+++ scoperegistry/DirWatcher.cpp	2015-01-13 07:11:02 +0000
@@ -137,12 +137,11 @@
             }
             catch (std::exception const& e)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error) << "~DirWatcher(): " << e.what();
+                BOOST_LOG(logger_) << "~DirWatcher(): " << e.what();
             }
             catch (...)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
-                    << "~DirWatcher(): watch_thread was aborted due to an unknown exception";
+                BOOST_LOG(logger_) << "~DirWatcher(): watch_thread was aborted due to an unknown exception";
             }
         }
         else
@@ -178,8 +177,6 @@
 #pragma GCC diagnostic pop
 
         int bytes_avail = 0;
-        static_assert(std::alignment_of<char*>::value >= std::alignment_of<struct inotify_event>::value,
-                      "cannot use std::string as buffer for inotify events");
         std::string buffer;
         std::string event_path;
 
@@ -223,7 +220,12 @@
             int i = 0;
             while (i < bytes_read)
             {
+                static_assert(std::alignment_of<char*>::value >= std::alignment_of<struct inotify_event>::value,
+                              "cannot use std::string as buffer for inotify events");
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
                 auto event = reinterpret_cast<inotify_event const*>(&buffer[i]);
+#pragma GCC diagnostic pop
                 {
                     event_path = "";
                     std::lock_guard<std::mutex> lock(mutex_);
@@ -281,14 +283,14 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << e.what();
+        BOOST_LOG(logger_) << "DirWatcher::watch_thread(): " << e.what();
         std::lock_guard<std::mutex> lock(mutex_);
         thread_state_ = Failed;
         thread_exception_ = std::current_exception();
     }
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "DirWatcher::watch_thread(): Thread aborted: unknown exception";
+        BOOST_LOG(logger_) << "DirWatcher::watch_thread(): Thread aborted: unknown exception";
         std::lock_guard<std::mutex> lock(mutex_);
         thread_state_ = Failed;
         thread_exception_ = std::current_exception();

=== modified file 'scoperegistry/ScopesWatcher.cpp'
--- scoperegistry/ScopesWatcher.cpp	2014-11-28 06:41:23 +0000
+++ scoperegistry/ScopesWatcher.cpp	2015-01-13 07:11:02 +0000
@@ -60,7 +60,7 @@
         catch (unity::LogicException const&) {} // Ignore already exists exception
         catch (unity::SyscallException const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error) << "ScopesWatcher::add_install_dir(): parent dir watch: " << e.what();
+            BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): parent dir watch: " << e.what();
         }
 
         // Create a new entry for this install dir into idir_to_sdirs_map_
@@ -101,11 +101,11 @@
     }
     catch (unity::ResourceException const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
+        BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
     }
     catch (unity::SyscallException const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
+        BOOST_LOG(logger_) << "ScopesWatcher::add_install_dir(): install dir watch: " << e.what();
     }
 }
 
@@ -199,7 +199,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "scoperegistry: add_scope_dir(): " << e.what();
+        BOOST_LOG(logger_) << "scoperegistry: add_scope_dir(): " << e.what();
     }
 }
 

=== modified file 'scoperegistry/scoperegistry.cpp'
--- scoperegistry/scoperegistry.cpp	2014-12-09 15:05:13 +0000
+++ scoperegistry/scoperegistry.cpp	2015-01-13 07:11:02 +0000
@@ -408,7 +408,7 @@
     {
     }
 
-    ScopeProxy proxy = ScopeImpl::create(mw->create_scope_proxy(scope.first), mw->runtime(), scope.first);
+    ScopeProxy proxy = ScopeImpl::create(mw->create_scope_proxy(scope.first), scope.first);
     mi->set_proxy(proxy);
     auto meta = ScopeMetadataImpl::create(std::move(mi));
 

=== modified file 'src/scopes/internal/ActivationQueryObject.cpp'
--- src/scopes/internal/ActivationQueryObject.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/ActivationQueryObject.cpp	2015-01-13 07:11:02 +0000
@@ -17,10 +17,12 @@
 */
 
 #include <unity/scopes/internal/ActivationQueryObject.h>
-#include <unity/scopes/ListenerBase.h>
+
 #include <unity/scopes/ActivationQueryBase.h>
+#include <unity/scopes/internal/MWQueryCtrl.h>
 #include <unity/scopes/internal/MWReply.h>
-#include <unity/scopes/internal/MWQueryCtrl.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/ListenerBase.h>
 
 #include <cassert>
 
@@ -38,9 +40,8 @@
 
 ActivationQueryObject::ActivationQueryObject(std::shared_ptr<ActivationQueryBase> const& act_base,
                                              MWReplyProxy const& reply,
-                                             MWQueryCtrlProxy const& ctrl,
-                                             boost::log::sources::severity_channel_logger_mt<>& logger)
-    : QueryObject(act_base, reply, ctrl, logger)
+                                             MWQueryCtrlProxy const& ctrl)
+    : QueryObject(act_base, reply, ctrl)
     , act_base_(act_base)
 {
 }
@@ -50,7 +51,7 @@
     // parent destructor will call ctrl_->destroy()
 }
 
-void ActivationQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& /* info */) noexcept
+void ActivationQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept
 {
     assert(self_);
 
@@ -70,12 +71,12 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ActivationQueryObject::run(): " << e.what();
+        BOOST_LOG(info.mw->runtime()->logger()) << "ActivationQueryObject::run(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error, e.what()));  // Oneway, can't block
     }
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ActivationQueryObject::run(): unknown exception";
+        BOOST_LOG(info.mw->runtime()->logger()) << "ActivationQueryObject::run(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error, "unknown exception"));  // Oneway, can't block
     }
 }

=== modified file 'src/scopes/internal/CategoryRegistry.cpp'
--- src/scopes/internal/CategoryRegistry.cpp	2014-07-02 09:36:34 +0000
+++ src/scopes/internal/CategoryRegistry.cpp	2015-01-13 07:11:02 +0000
@@ -18,6 +18,8 @@
 
 #include <unity/scopes/internal/CategoryRegistry.h>
 #include <unity/UnityExceptions.h>
+
+#include <algorithm>
 #include <sstream>
 
 namespace unity
@@ -32,13 +34,13 @@
 void CategoryRegistry::register_category(Category::SCPtr category)
 {
     std::lock_guard<decltype(mutex_)> lock(mutex_);
-    if (categories_.find(category->id()) != categories_.end())
+    auto id = category->id();
+    auto it = find_if(categories_.begin(), categories_.end(), [id](const CatPair& p) { return p.first == id; });
+    if (it != categories_.end())
     {
-        std::ostringstream s;
-        s << "Category " << category->id() << " already defined";
-        throw InvalidArgumentException(s.str());
+        throw InvalidArgumentException("register_category(): duplicate category: " + id);
     }
-    categories_[category->id()] = category;
+    categories_.push_back(make_pair(category->id(), category));
 }
 
 Category::SCPtr CategoryRegistry::register_category(VariantMap const& variant_map)
@@ -58,7 +60,7 @@
 Category::SCPtr CategoryRegistry::lookup_category(std::string const& id) const
 {
     std::lock_guard<decltype(mutex_)> lock(mutex_);
-    auto it = categories_.find(id);
+    auto it = find_if(categories_.begin(), categories_.end(), [id](const CatPair& p) { return p.first == id; });
     if (it != categories_.end())
     {
         return it->second;
@@ -66,6 +68,17 @@
     return nullptr;
 }
 
+VariantArray CategoryRegistry::serialize() const
+{
+    std::lock_guard<decltype(mutex_)> lock(mutex_);
+    VariantArray va;
+    for (auto&& p : categories_)
+    {
+        va.push_back(Variant(p.second->serialize()));
+    }
+    return va;
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/JsonCppNode.cpp'
--- src/scopes/internal/JsonCppNode.cpp	2014-08-18 08:12:22 +0000
+++ src/scopes/internal/JsonCppNode.cpp	2015-01-13 07:11:02 +0000
@@ -276,7 +276,7 @@
     return std::make_shared<JsonCppNode>(value_node);
 }
 
-JsonNodeInterface::SPtr JsonCppNode::get_node(uint node_index) const
+JsonNodeInterface::SPtr JsonCppNode::get_node(unsigned int node_index) const
 {
     if (root_.type() != Json::arrayValue)
     {

=== modified file 'src/scopes/internal/Logger.cpp'
--- src/scopes/internal/Logger.cpp	2014-12-01 12:41:49 +0000
+++ src/scopes/internal/Logger.cpp	2015-01-13 07:11:02 +0000
@@ -24,7 +24,9 @@
 #include <boost/log/sources/record_ostream.hpp>
 #include <boost/log/support/date_time.hpp>
 #include <boost/log/trivial.hpp>
+#include <boost/phoenix/bind.hpp>
 #include <boost/utility/empty_deleter.hpp>
+#include <unity/UnityExceptions.h>
 
 using namespace std;
 
@@ -47,9 +49,14 @@
 namespace
 {
 
-string const& severity(int s)
+static array<string, Logger::LastChannelEnum_> const channel_names =
+    {
+        "IPC"
+    };
+
+string const& to_severity(int s)
 {
-    static array<string, 5> const severities = { { "TRACE", "INFO", "WARNING", "ERROR", "FATAL" } };
+    static array<string, 5> const severities = { { "INFO", "WARNING", "ERROR", "FATAL", "TRACE" } };
     static string const unknown = "UNKNOWN";
 
     if (s < 0 || s >= static_cast<int>(severities.size()))
@@ -59,31 +66,13 @@
     return severities[s];
 }
 
-void formatter(logging::record_view const& rec, logging::formatting_ostream& strm, string const& scope_id)
-{
-    strm << "[" << expr::format_date_time<boost::posix_time::ptime>("TimeStamp", "%Y-%m-%d %H:%M:%S.%f")(rec) << "] "
-         << severity(expr::attr<int>("Severity")(rec).get()) << ": "
-         << scope_id << ": "
-         << rec[expr::smessage];
-}
-
 }
 
 // Instantiate a logger for the scope/client with the given ID.
-//
-// Note: channel is our own address in memory. This gives
-//       us a unique identity. The id passed by the run time
-//       is *not* necessarily unique. (It is normally, but
-//       some of the tests instantiate more than one run time
-//       in a single address space, not always necessarily with
-//       a unique scope id. Using a unique ID guarantees
-//       that a log message writting by one run time isn't
-//       also written a second time by a run time that
-//       happens to have the same ID.
 
 Logger::Logger(string const& scope_id)
     : scope_id_(scope_id)
-    , logger_(keywords::channel = to_string(reinterpret_cast<ptrdiff_t>(this)))
+    , logger_(keywords::severity = Logger::Error)
     , severity_(Logger::Info)
 {
     namespace ph = std::placeholders;
@@ -92,11 +81,21 @@
 
     logger_.add_attribute("TimeStamp", attrs::local_clock());
 
+    // Create a channel logger for each channel.
+    for (auto&& name : channel_names)
+    {
+        auto clogger = boost::log::sources::severity_channel_logger_mt<>(keywords::severity = Logger::Trace,
+                                                                         keywords::channel = name);
+        clogger.add_attribute("TimeStamp", attrs::local_clock());
+        channel_loggers_[name] = make_pair(clogger, false);
+    }
+
     // Set up sink that logs to std::clog.
     clog_sink_ = boost::make_shared<ClogSinkT>();
-    clog_sink_->set_formatter(std::bind(formatter, ph::_1, ph::_2, scope_id));
+    clog_sink_->set_formatter(bind(&Logger::formatter, this, ph::_1, ph::_2));
     boost::shared_ptr<std::ostream> console_stream(&std::clog, boost::empty_deleter());
     clog_sink_->locked_backend()->add_stream(console_stream);
+    clog_sink_->locked_backend()->auto_flush(true);
     logging::core::get()->add_sink(clog_sink_);
 
     set_severity_threshold(severity_);
@@ -104,49 +103,113 @@
 
 Logger::~Logger()
 {
+    lock_guard<mutex> lock(mutex_);
+
     if (clog_sink_)
     {
         logging::core::get()->remove_sink(clog_sink_);
+        clog_sink_->stop();
+        clog_sink_->flush();
     }
     else
     {
         logging::core::get()->remove_sink(file_sink_);
-    }
-}
-
-Logger::operator src::severity_channel_logger_mt<>&()
-{
-    return logger_;
-}
-
-void Logger::set_log_file(string const& path)
+        file_sink_->stop();
+        file_sink_->flush();
+    }
+}
+
+Logger::operator boost::log::sources::severity_channel_logger_mt<>&()
+{
+    return logger_;  // No lock needed, immutable
+}
+
+src::severity_channel_logger_mt<>& Logger::operator()(Channel c)
+{
+    // No lock needed: channel_loggers_ is immutable, and the boolean is atomic.
+    return channel_loggers_[channel_names[c]].first;
+}
+
+bool Logger::set_channel(Channel c, bool enable)
+{
+    auto it = channel_loggers_.find(channel_names[c]);
+    assert(it != channel_loggers_.end());
+    bool was_enabled = it->second.second.exchange(enable);
+    return was_enabled;
+}
+
+bool Logger::set_channel(string channel_name, bool enable)
+{
+    auto it = channel_loggers_.find(channel_name);
+    if (it == channel_loggers_.end())
+    {
+        throw InvalidArgumentException("Logger::set_channel(): invalid channel name: " + channel_name);
+    }
+    bool was_enabled = it->second.second.exchange(enable);
+    return was_enabled;
+}
+
+void Logger::enable_channels(vector<string> const& names)
+{
+    exception_ptr ep;
+    for (auto&& name : names)
+    {
+        try
+        {
+            set_channel(name, true);
+        }
+        catch (InvalidArgumentException& e)
+        {
+            ep = ep ? make_exception_ptr(current_exception()) : e.remember(ep);
+        }
+    }
+    if (ep)
+    {
+        rethrow_exception(ep);
+    }
+}
+
+void Logger::set_log_file(string const& path, int rotation_size, int dir_size)
 {
     namespace ph = std::placeholders;
 
     FileSinkPtr s = boost::make_shared<FileSinkT>(
-                        keywords::file_name = path + "_%N.log",
-                        keywords::rotation_size = 5 * 1024 * 1024,
-                        keywords::time_based_rotation = sinks::file::rotation_at_time_point(12, 0, 0));
-    if (clog_sink_)
-    {
-        logging::core::get()->remove_sink(clog_sink_);
-    }
-    else
-    {
-        logging::core::get()->remove_sink(file_sink_);
-    }
-    file_sink_ = s;
+                        keywords::file_name = path + "-%N.log",
+                        keywords::rotation_size = rotation_size);
+
+    string parent = boost::filesystem::path(path).parent_path().native();
+    s->locked_backend()->set_file_collector(sinks::file::make_collector(keywords::target = parent,
+                                                                        keywords::max_size = dir_size));
+    s->locked_backend()->scan_for_files();
+
+    {
+        lock_guard<mutex> lock(mutex_);
+
+        if (clog_sink_)
+        {
+            logging::core::get()->remove_sink(clog_sink_);
+            clog_sink_ = nullptr;
+        }
+        else
+        {
+            logging::core::get()->remove_sink(file_sink_);
+        }
+
+        file_sink_ = s;
+        file_sink_->locked_backend()->auto_flush(true);
+        file_sink_->set_formatter(bind(&Logger::formatter, this, ph::_1, ph::_2));
+        logging::core::get()->add_sink(file_sink_);
+    }
     set_severity_threshold(severity_);
-    file_sink_->set_formatter(std::bind(formatter, ph::_1, ph::_2, scope_id_));
-    logging::core::get()->add_sink(s);
 }
 
 Logger::Severity Logger::set_severity_threshold(Logger::Severity s)
 {
-    auto old_s = severity_;
-    severity_ = s;
-    auto filter = expr::attr<string>("Channel") == to_string(reinterpret_cast<ptrdiff_t>(this))
-                  && expr::attr<int>("Severity") >= static_cast<int>(severity_);
+    auto old_s = severity_.exchange(s);
+
+    lock_guard<mutex> lock(mutex_);
+
+    auto filter = boost::phoenix::bind(&Logger::filter, this, severity.or_none(), channel.or_none());
     if (clog_sink_)
     {
         clog_sink_->set_filter(filter);
@@ -155,9 +218,40 @@
     {
         file_sink_->set_filter(filter);
     }
+
     return old_s;
 }
 
+bool Logger::filter(logging::value_ref<int, tag::severity> const& level,
+                    logging::value_ref<string, tag::channel> const& channel)
+{
+    if (level.get() < static_cast<int>(severity_))  // atomic
+    {
+        return false;
+    }
+    if (channel.get().empty())
+    {
+        return true;
+    }
+    // No lock needed: channel_loggers_ is immutable, and the boolean is atomic.
+    auto it = channel_loggers_.find(channel.get());
+    assert(it != channel_loggers_.end());
+    return it->second.second;
+}
+
+void Logger::formatter(logging::record_view const& rec,
+                       logging::formatting_ostream& strm)
+{
+    string channel = expr::attr<string>("Channel")(rec).get();
+
+    string prefix = channel.empty() ? to_severity(expr::attr<int>("Severity")(rec).get()) : channel;
+
+    strm << "[" << expr::format_date_time<boost::posix_time::ptime>("TimeStamp", "%Y-%m-%d %H:%M:%S.%f")(rec) << "] "
+         << prefix << ": "
+         << scope_id_ << ": "
+         << rec[expr::smessage];
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/ObjectImpl.cpp'
--- src/scopes/internal/ObjectImpl.cpp	2014-11-20 07:06:57 +0000
+++ src/scopes/internal/ObjectImpl.cpp	2015-01-13 07:11:02 +0000
@@ -35,10 +35,8 @@
 namespace internal
 {
 
-ObjectImpl::ObjectImpl(MWProxy const& mw_proxy, boost::log::sources::severity_channel_logger_mt<>& logger)
-    : logger_(logger)
+ObjectImpl::ObjectImpl(MWProxy const& mw_proxy)
 {
-    lock_guard<mutex> lock(proxy_mutex_); // TODO: Why this lock?
     mw_proxy_ = mw_proxy;
 }
 

=== modified file 'src/scopes/internal/PreviewQueryObject.cpp'
--- src/scopes/internal/PreviewQueryObject.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/PreviewQueryObject.cpp	2015-01-13 07:11:02 +0000
@@ -16,10 +16,12 @@
  * Authored by: Michal Hruby <[e-mail]>
 */
 
+#include <unity/scopes/internal/PreviewQueryObject.h>
+
 #include <unity/scopes/internal/MWQueryCtrl.h>
 #include <unity/scopes/internal/MWReply.h>
-#include <unity/scopes/internal/PreviewQueryObject.h>
 #include <unity/scopes/internal/PreviewReplyImpl.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/ListenerBase.h>
 #include <unity/scopes/PreviewReply.h>
 #include <unity/scopes/QueryBase.h>
@@ -41,9 +43,8 @@
 
 PreviewQueryObject::PreviewQueryObject(std::shared_ptr<PreviewQueryBase> const& preview_base,
                                        MWReplyProxy const& reply,
-                                       MWQueryCtrlProxy const& ctrl,
-                                       boost::log::sources::severity_channel_logger_mt<>& logger)
-    : QueryObject(preview_base, reply, ctrl, logger)
+                                       MWQueryCtrlProxy const& ctrl)
+    : QueryObject(preview_base, reply, ctrl)
     , preview_base_(preview_base)
 {
     assert(preview_base);
@@ -54,11 +55,11 @@
     // parent destructor will call ctrl_->destroy()
 }
 
-void PreviewQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& /* info */) noexcept
+void PreviewQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept
 {
     assert(self_);
 
-    auto reply_proxy = make_shared<PreviewReplyImpl>(reply, self_, logger_);
+    auto reply_proxy = make_shared<PreviewReplyImpl>(reply, self_);
     assert(reply_proxy);
     reply_proxy_ = reply_proxy;
 
@@ -78,12 +79,12 @@
     catch (std::exception const& e)
     {
         pushable_ = false;
-        BOOST_LOG_SEV(logger_, Logger::Error) << "PreviewQueryObject::run(): " << e.what();
+        BOOST_LOG(info.mw->runtime()->logger()) << "PreviewQueryObject::run(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error, e.what()));  // Oneway, can't block
     }
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "PreviewQueryObject::run(): unknown exception";
+        BOOST_LOG(info.mw->runtime()->logger()) << "PreviewQueryObject::run(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error, "unknown exception"));  // Oneway, can't block
     }
 }

=== modified file 'src/scopes/internal/PreviewReplyImpl.cpp'
--- src/scopes/internal/PreviewReplyImpl.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/PreviewReplyImpl.cpp	2015-01-13 07:11:02 +0000
@@ -34,11 +34,9 @@
 namespace internal
 {
 
-PreviewReplyImpl::PreviewReplyImpl(MWReplyProxy const& mw_proxy,
-                                   shared_ptr<QueryObjectBase> const& qo,
-                                   boost::log::sources::severity_channel_logger_mt<>& logger)
-    : ObjectImpl(mw_proxy, logger)
-    , ReplyImpl(mw_proxy, qo, logger)
+PreviewReplyImpl::PreviewReplyImpl(MWReplyProxy const& mw_proxy, shared_ptr<QueryObjectBase> const& qo)
+    : ObjectImpl(mw_proxy)
+    , ReplyImpl(mw_proxy, qo)
     , layouts_push_disallowed_(false)
 {
 }

=== modified file 'src/scopes/internal/QueryCtrlImpl.cpp'
--- src/scopes/internal/QueryCtrlImpl.cpp	2014-11-20 05:47:58 +0000
+++ src/scopes/internal/QueryCtrlImpl.cpp	2015-01-13 07:11:02 +0000
@@ -39,9 +39,8 @@
 {
 
 QueryCtrlImpl::QueryCtrlImpl(MWQueryCtrlProxy const& ctrl_proxy,
-                             MWReplyProxy const& reply_proxy,
-                             boost::log::sources::severity_channel_logger_mt<>& logger)
-    : ObjectImpl(ctrl_proxy, logger)
+                             MWReplyProxy const& reply_proxy)
+    : ObjectImpl(ctrl_proxy)
     , reply_proxy_(reply_proxy)
 {
     // We remember the reply proxy so, when the query is cancelled, we can
@@ -82,7 +81,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << e.what();
+        BOOST_LOG(reply_proxy_->mw_base()->runtime()->logger()) << e.what();
     }
 }
 

=== modified file 'src/scopes/internal/QueryObject.cpp'
--- src/scopes/internal/QueryObject.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/QueryObject.cpp	2015-01-13 07:11:02 +0000
@@ -22,9 +22,10 @@
 #include <unity/scopes/ActivationQueryBase.h>
 #include <unity/scopes/internal/MWQueryCtrl.h>
 #include <unity/scopes/internal/MWReply.h>
+#include <unity/scopes/internal/QueryBaseImpl.h>
 #include <unity/scopes/internal/QueryCtrlObject.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/internal/SearchReplyImpl.h>
-#include <unity/scopes/internal/QueryBaseImpl.h>
 #include <unity/scopes/PreviewQueryBase.h>
 #include <unity/scopes/QueryBase.h>
 #include <unity/scopes/SearchQueryBase.h>
@@ -45,23 +46,20 @@
 
 QueryObject::QueryObject(std::shared_ptr<QueryBase> const& query_base,
                          MWReplyProxy const& reply,
-                         MWQueryCtrlProxy const& ctrl,
-                         boost::log::sources::severity_channel_logger_mt<>& logger)
-    : QueryObject(query_base, 0, reply, ctrl, logger)
+                         MWQueryCtrlProxy const& ctrl)
+    : QueryObject(query_base, 0, reply, ctrl)
 {
 }
 
 QueryObject::QueryObject(std::shared_ptr<QueryBase> const& query_base,
                          int cardinality,
                          MWReplyProxy const& reply,
-                         MWQueryCtrlProxy const& ctrl,
-                         boost::log::sources::severity_channel_logger_mt<>& logger)
+                         MWQueryCtrlProxy const& ctrl)
     : query_base_(query_base)
     , reply_(reply)
     , ctrl_(ctrl)
     , pushable_(true)
     , cardinality_(cardinality)
-    , logger_(logger)
 {
 }
 
@@ -78,7 +76,7 @@
     }
 }
 
-void QueryObject::run(MWReplyProxy const& reply, InvokeInfo const& /* info */) noexcept
+void QueryObject::run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept
 {
     unique_lock<mutex> lock(mutex_);
 
@@ -103,7 +101,11 @@
     // Create the reply proxy to pass to query_base_ and keep a weak_ptr, which we will need
     // if cancel() is called later.
     assert(self_);
-    auto reply_proxy = make_shared<SearchReplyImpl>(reply, self_, cardinality_, search_query->department_id(), logger_);
+    auto reply_proxy = make_shared<SearchReplyImpl>(reply,
+                                                    self_,
+                                                    cardinality_,
+                                                    search_query->query().query_string(),
+                                                    search_query->department_id());
     assert(reply_proxy);
     reply_proxy_ = reply_proxy;
 
@@ -123,13 +125,13 @@
     catch (std::exception const& e)
     {
         pushable_ = false;
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ScopeBase::run(): " << e.what();
+        BOOST_LOG(info.mw->runtime()->logger()) << "ScopeBase::run(): " << e.what();
         reply_->finished(CompletionDetails(CompletionDetails::Error, e.what()));  // Oneway, can't block
     }
     catch (...)
     {
         pushable_ = false;
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ScopeBase::run(): unknown exception";
+        BOOST_LOG(info.mw->runtime()->logger()) << "ScopeBase::run(): unknown exception";
         reply_->finished(CompletionDetails(CompletionDetails::Error, "unknown exception"));  // Oneway, can't block
     }
 }

=== modified file 'src/scopes/internal/RegistryImpl.cpp'
--- src/scopes/internal/RegistryImpl.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/RegistryImpl.cpp	2015-01-13 07:11:02 +0000
@@ -32,8 +32,8 @@
 namespace internal
 {
 
-RegistryImpl::RegistryImpl(MWRegistryProxy const& mw_proxy, RuntimeImpl* runtime)
-    : ObjectImpl(mw_proxy, runtime->logger())
+RegistryImpl::RegistryImpl(MWRegistryProxy const& mw_proxy)
+    : ObjectImpl(mw_proxy)
 {
 }
 

=== modified file 'src/scopes/internal/RegistryObject.cpp'
--- src/scopes/internal/RegistryObject.cpp	2014-12-08 13:27:57 +0000
+++ src/scopes/internal/RegistryObject.cpp	2015-01-13 07:11:02 +0000
@@ -92,8 +92,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "RegistryObject(): failed to create registry publisher: " << e.what();
+            BOOST_LOG(logger_) << "RegistryObject(): failed to create registry publisher: " << e.what();
         }
     }
 }
@@ -122,8 +121,7 @@
         }
         catch(std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "RegistryObject::~RegistryObject(): " << e.what();
+            BOOST_LOG(logger_) << "RegistryObject::~RegistryObject(): " << e.what();
         }
     }
 }
@@ -157,8 +155,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "cannot get metadata from remote registry: " << e.what();
+            BOOST_LOG(logger_) << "cannot get metadata from remote registry: " << e.what();
         }
     }
 
@@ -186,8 +183,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "cannot get scopes list from remote registry: " << e.what();
+            BOOST_LOG(logger_) << "cannot get scopes list from remote registry: " << e.what();
         }
     }
 
@@ -382,7 +378,7 @@
                 it->second->update_state(ScopeProcess::ProcessState::Stopping);
                 break;
             default:
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "RegistryObject::on_state_received(): unknown state received from scope: " << scope_id;
         }
     }
@@ -484,7 +480,7 @@
     }
     catch(std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "RegistryObject::ScopeProcess::~ScopeProcess(): " << e.what();
+        BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::~ScopeProcess(): " << e.what();
     }
 }
 
@@ -523,7 +519,7 @@
     {
         if (!wait_for_state(lock, ScopeProcess::Stopped))
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "RegistryObject::ScopeProcess::exec(): Force killing process. Scope: \""
                 << exec_data_.scope_id << "\" did not stop after " << exec_data_.timeout_ms << " ms.";
             try
@@ -532,8 +528,7 @@
             }
             catch(std::exception const& e)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
-                    << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
+                BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
             }
         }
     }
@@ -605,8 +600,7 @@
         }
         catch(std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
+            BOOST_LOG(logger_) << "RegistryObject::ScopeProcess::exec(): kill() failed: " << e.what();
         }
         throw unity::ResourceException("RegistryObject::ScopeProcess::exec(): exec aborted. Scope: \""
                                        + exec_data_.scope_id + "\" took longer than "
@@ -683,7 +677,7 @@
 
         if (state_ != Stopping)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "RegistryObject::ScopeProcess: Scope: \"" << exec_data_.scope_id
                 << "\" closed unexpectedly. Either the process crashed or was killed forcefully.";
         }
@@ -696,7 +690,7 @@
             reg_publisher->send_message("stopped", exec_data_.scope_id);
         }
 
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "RegistryObject::ScopeProcess: Manually started process for scope: \""
             << exec_data_.scope_id << "\" exited";
 
@@ -730,7 +724,7 @@
         {
             std::error_code ec;
 
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "RegistryObject::ScopeProcess::kill(): Scope: \"" << exec_data_.scope_id
                 << "\" took longer than " << exec_data_.timeout_ms << " ms to exit gracefully. "
                 << "Killing the process instead.";
@@ -744,7 +738,7 @@
     }
     catch (std::exception const&)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "RegistryObject::ScopeProcess::kill(): Failed to kill scope: \"" << exec_data_.scope_id << "\"";
 
         // clear the process handle
@@ -820,7 +814,7 @@
             started_message += " string:" + exec_data_.scope_id + " uint64:" + std::to_string(process_.pid());
             if (safe_system_call(started_message) != 0)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "RegistryObject::ScopeProcess::publish_state_change(): "
                        "Failed to execute SDK DBus ScopeLoaded callback "
                        "(Scope ID: " << exec_data_.scope_id << ")";
@@ -841,7 +835,7 @@
             stopped_message += " string:" + exec_data_.scope_id;
             if (safe_system_call(stopped_message) != 0)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "RegistryObject::ScopeProcess::publish_state_change(): "
                        "Failed to execute SDK DBus ScopeStopped callback "
                        "(Scope ID: " << exec_data_.scope_id << ")";

=== modified file 'src/scopes/internal/ReplyImpl.cpp'
--- src/scopes/internal/ReplyImpl.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/ReplyImpl.cpp	2015-01-13 07:11:02 +0000
@@ -38,10 +38,8 @@
 namespace internal
 {
 
-ReplyImpl::ReplyImpl(MWReplyProxy const& mw_proxy,
-                     std::shared_ptr<QueryObjectBase> const& qo,
-                     boost::log::sources::severity_channel_logger_mt<>& logger)
-    : ObjectImpl(mw_proxy, logger)
+ReplyImpl::ReplyImpl(MWReplyProxy const& mw_proxy, std::shared_ptr<QueryObjectBase> const& qo)
+    : ObjectImpl(mw_proxy)
     , qo_(qo)
     , finished_(false)
 {
@@ -94,7 +92,7 @@
         {
             fwd()->finished(CompletionDetails(CompletionDetails::OK));  // Oneway, can't block
         }
-        catch (std::exception const& e)
+        catch (std::exception const&)
         {
             // No logging here because this may happen after the run time is destroyed.
         }
@@ -123,7 +121,7 @@
     {
         error_message = "unknown exception";
     }
-    BOOST_LOG_SEV(logger_, Logger::Error) << "ReplyImpl::error(): " << error_message;
+    BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger()) << "ReplyImpl::error(): " << error_message;
 
     try
     {
@@ -131,7 +129,8 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ReplyImpl::error(): excpetion from finished(): " << error_message;
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "ReplyImpl::error(): excpetion from finished(): " << error_message;
     }
 }
 
@@ -148,7 +147,8 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "ReplyImpl::error(): excpetion from info(): " << e.what();
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "ReplyImpl::error(): excpetion from info(): " << e.what();
     }
 }
 

=== modified file 'src/scopes/internal/ReplyObject.cpp'
--- src/scopes/internal/ReplyObject.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/ReplyObject.cpp	2015-01-13 07:11:02 +0000
@@ -183,11 +183,11 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << "ReplyObject::finished(): " << e.what();
+        BOOST_LOG(runtime_->logger()) << "ReplyObject::finished(): " << e.what();
     }
     catch (...)
     {
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << "ReplyObject::finished(): unknown exception";
+        BOOST_LOG(runtime_->logger()) << "ReplyObject::finished(): unknown exception";
     }
 
     // Disconnect self from middleware, if this hasn't happened yet.
@@ -217,11 +217,11 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << "ReplyObject::info(): " << e.what();
+        BOOST_LOG(runtime_->logger()) << "ReplyObject::info(): " << e.what();
     }
     catch (...)
     {
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << "ReplyObject::info(): unknown exception";
+        BOOST_LOG(runtime_->logger()) << "ReplyObject::info(): unknown exception";
     }
 }
 

=== modified file 'src/scopes/internal/ResultReplyObject.cpp'
--- src/scopes/internal/ResultReplyObject.cpp	2014-08-12 09:04:49 +0000
+++ src/scopes/internal/ResultReplyObject.cpp	2015-01-13 07:11:02 +0000
@@ -17,7 +17,6 @@
  */
 
 #include <unity/scopes/internal/ResultReplyObject.h>
-#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/internal/AnnotationImpl.h>
 #include <unity/scopes/ListenerBase.h>
 #include <unity/scopes/Category.h>
@@ -43,6 +42,8 @@
 namespace internal
 {
 
+class RuntimeImpl;
+
 ResultReplyObject::ResultReplyObject(SearchListenerBase::SPtr const& receiver, RuntimeImpl const* runtime,
                                      std::string const& scope_id, int cardinality, bool dont_reap) :
     ReplyObject(std::static_pointer_cast<ListenerBase>(receiver), runtime, scope_id, dont_reap),

=== modified file 'src/scopes/internal/RuntimeConfig.cpp'
--- src/scopes/internal/RuntimeConfig.cpp	2014-11-13 00:28:01 +0000
+++ src/scopes/internal/RuntimeConfig.cpp	2015-01-13 07:11:02 +0000
@@ -19,8 +19,16 @@
 #include <unity/scopes/internal/RuntimeConfig.h>
 
 #include <unity/scopes/internal/DfltConfig.h>
+#include <unity/scopes/ScopeExceptions.h>
+
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/constants.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/filesystem.hpp>
 #include <unity/UnityExceptions.h>
 
+#include <sys/stat.h>
+
 #include <stdlib.h>
 
 using namespace std;
@@ -49,6 +57,10 @@
 const string cache_dir_key = "CacheDir";
 const string app_dir_key = "AppDir";
 const string config_dir_key = "ConfigDir";
+const string log_dir_key = "LogDir";
+const string max_log_file_size_key = "Log.MaxFileSize";
+const string max_log_dir_size_key = "Log.MaxDirSize";
+const string trace_channels_key = "Log.TraceChannels";
 
 }  // namespace
 
@@ -65,16 +77,12 @@
         default_middleware_configfile_ = DFLT_ZMQ_MIDDLEWARE_INI;
         reap_expiry_ = DFLT_REAP_EXPIRY;
         reap_interval_ = DFLT_REAP_INTERVAL;
-        try
-        {
-            cache_directory_ = default_cache_directory();
-            app_directory_ = default_app_directory();
-            config_directory_ = default_config_directory();
-        }
-        catch (ResourceException const& e)
-        {
-            throw_ex("Failed to get default data directory");
-        }
+        max_log_file_size_ = DFLT_MAX_LOG_FILE_SIZE;
+        max_log_dir_size_ = DFLT_MAX_LOG_DIR_SIZE;
+        cache_directory_ = default_cache_directory();
+        app_directory_ = default_app_directory();
+        config_directory_ = default_config_directory();
+        log_directory_ = default_log_directory();
     }
     else
     {
@@ -96,6 +104,7 @@
         {
             throw_ex("Illegal value (" + to_string(reap_interval_) + ") for " + reap_interval_key + ": value must be > 0");
         }
+
         cache_directory_ = get_optional_string(runtime_config_group, cache_dir_key);
         if (cache_directory_.empty())
         {
@@ -105,9 +114,10 @@
             }
             catch (ResourceException const& e)
             {
-                throw_ex("No CacheDir configured and failed to get default");
+                throw_ex("No " + cache_dir_key + " configured and failed to get default");
             }
         }
+
         app_directory_ = get_optional_string(runtime_config_group, app_dir_key);
         if (app_directory_.empty())
         {
@@ -117,9 +127,10 @@
             }
             catch (ResourceException const& e)
             {
-                throw_ex("No AppDir configured and failed to get default");
+                throw_ex("No " + app_dir_key + " configured and failed to get default");
             }
         }
+
         config_directory_ = get_optional_string(runtime_config_group, config_dir_key);
         if (config_directory_.empty())
         {
@@ -129,8 +140,65 @@
             }
             catch (ResourceException const& e)
             {
-                throw_ex("No ConfigDir configured and failed to get default");
-            }
+                throw_ex("No " + config_dir_key + " configured and failed to get default");
+            }
+        }
+
+        try
+        {
+            // If explicitly set to the empty string, we succeed here.
+            log_directory_ = parser()->get_string(runtime_config_group, log_dir_key);
+        }
+        catch (LogicException const&)
+        {
+            // Use default value.
+            try
+            {
+                log_directory_ = default_log_directory();
+            }
+            catch (ResourceException const& e)
+            {
+                throw_ex("No " + log_dir_key + " configured and failed to get default");
+            }
+        }
+
+        // Check if we have an override for the log directory.
+        char const* logdir = getenv("UNITY_SCOPES_LOGDIR");
+        if (logdir)
+        {
+            log_directory_ = logdir;
+        }
+
+        max_log_file_size_ = get_optional_int(runtime_config_group, max_log_file_size_key, DFLT_MAX_LOG_FILE_SIZE);
+        if (max_log_file_size_ < 1024)
+        {
+            throw_ex("Illegal value (" + to_string(max_log_file_size_) + ") for " + max_log_file_size_key
+                     + ": value must be > 1024");
+        }
+
+        max_log_dir_size_ = get_optional_int(runtime_config_group, max_log_dir_size_key, DFLT_MAX_LOG_DIR_SIZE);
+        if (max_log_dir_size_ <= max_log_file_size_)
+        {
+            throw_ex("Illegal value (" + to_string(max_log_dir_size_) + ") for " + max_log_dir_size_key
+                     + ": value must be > " + max_log_file_size_key + " (" + to_string(max_log_file_size_) + ")");
+        }
+
+        try
+        {
+            trace_channels_ = parser()->get_string_array(runtime_config_group, trace_channels_key);
+        }
+        catch (LogicException const&)
+        {
+            // No TraceChannels configured.
+        }
+
+        // Check if we have an override for the trace channels.
+        char const* tc = getenv("UNITY_SCOPES_LOG_TRACECHANNELS");
+        if (tc && *tc != '\0')
+        {
+            vector<string> channels;
+            split(channels, tc, boost::is_any_of(";"), boost::token_compress_on);
+            trace_channels_ = channels;
         }
     }
 
@@ -147,7 +215,11 @@
                                                 reap_interval_key,
                                                 cache_dir_key,
                                                 app_dir_key,
-                                                config_dir_key
+                                                config_dir_key,
+                                                log_dir_key,
+                                                max_log_file_size_key,
+                                                max_log_dir_size_key,
+                                                trace_channels_key
                                              }
                                           }
                                        };
@@ -213,6 +285,26 @@
     return config_directory_;
 }
 
+string RuntimeConfig::log_directory() const
+{
+    return log_directory_;
+}
+
+int RuntimeConfig::max_log_file_size() const
+{
+    return max_log_file_size_;
+}
+
+int RuntimeConfig::max_log_dir_size() const
+{
+    return max_log_dir_size_;
+}
+
+vector<string> RuntimeConfig::trace_channels() const
+{
+    return trace_channels_;
+}
+
 string RuntimeConfig::default_cache_directory()
 {
     char const* home = getenv("HOME");
@@ -220,7 +312,7 @@
     {
         throw ResourceException("RuntimeConfig::default_cache_directory(): $HOME not set");
     }
-    return string(home) + "/.local/share/unity-scopes";
+    return string(home) + "/" + DFLT_HOME_CACHE_SUBDIR;
 }
 
 string RuntimeConfig::default_app_directory()
@@ -230,7 +322,7 @@
     {
         throw ResourceException("RuntimeConfig::default_app_directory(): $HOME not set");
     }
-    return string(home) + "/.local/share";
+    return string(home) + "/" + DFLT_HOME_APP_SUBDIR;
 }
 
 string RuntimeConfig::default_config_directory()
@@ -240,7 +332,22 @@
     {
         throw ResourceException("RuntimeConfig::default_config_directory(): $HOME not set");
     }
-    return string(home) + "/.config/unity-scopes";
+    return string(home) + "/" + DFLT_HOME_CONFIG_SUBDIR;
+}
+
+string RuntimeConfig::default_log_directory()
+{
+    char const* home = getenv("HOME");
+    if (!home || *home == '\0')
+    {
+        throw ResourceException("RuntimeConfig::default_log_directory(): $HOME not set");
+    }
+    string dir = string(home) + "/" + DFLT_HOME_LOG_SUBDIR;
+
+    boost::system::error_code ec;
+    !boost::filesystem::exists(dir, ec) && ::mkdir(dir.c_str(), 0700);
+
+    return dir;
 }
 
 } // namespace internal

=== modified file 'src/scopes/internal/RuntimeImpl.cpp'
--- src/scopes/internal/RuntimeImpl.cpp	2014-12-04 04:33:50 +0000
+++ src/scopes/internal/RuntimeImpl.cpp	2015-01-13 07:11:02 +0000
@@ -59,15 +59,17 @@
 {
     try
     {
-        lock_guard<mutex> lock(mutex_);
+        lock_guard<mutex> lock(mutex_);  // TODO: shouldn't be necessary.
 
         destroyed_ = false;
 
         scope_id_ = scope_id;
+        string log_file_basename = scope_id;
         if (scope_id_.empty())
         {
             UniqueID id;
             scope_id_ = "c-" + id.gen();
+            log_file_basename = "client";  // Don't make lots of log files named like c-c4c758b100000000.
         }
 
         // Until we know where the scope's cache directory is,
@@ -77,6 +79,28 @@
         // Create the middleware factory and get the registry identity and config filename.
         runtime_configfile_ = configfile;
         RuntimeConfig config(configfile);
+
+        // Configure trace channels.
+        try
+        {
+            logger_->enable_channels(config.trace_channels());
+        }
+        catch (...)
+        {
+            throw InvalidArgumentException("Runtime(): invalid trace channel name(s)");
+        }
+
+        // Now that we have the config, change the logger to log to a file.
+        // If log_dir was explicitly set to the empty string, continue
+        // logging to std::clog.
+        string log_dir = config.log_directory();
+        if (!log_dir.empty())
+        {
+            logger_->set_log_file(config.log_directory() + "/" + log_file_basename,
+                                  config.max_log_file_size(),
+                                  config.max_log_dir_size());
+        }
+
         string default_middleware = config.default_middleware();
         string middleware_configfile = config.default_middleware_configfile();
         middleware_factory_.reset(new MiddlewareFactory(this));
@@ -104,7 +128,7 @@
             // Create the registry proxy
             RegistryConfig reg_config(registry_identity_, registry_configfile_);
             auto registry_mw_proxy = middleware_->registry_proxy();
-            registry_ = make_shared<RegistryImpl>(registry_mw_proxy, this);
+            registry_ = make_shared<RegistryImpl>(registry_mw_proxy);
         }
 
         cache_dir_ = config.cache_directory();
@@ -117,7 +141,7 @@
         string msg = "Cannot instantiate run time for " + (scope_id.empty() ? "client" : scope_id) +
                      ", config file: " + configfile;
         ConfigException ex(msg);
-        BOOST_LOG_SEV(logger(), Logger::Error) << ex.what();
+        BOOST_LOG(logger()) << ex.what();
         throw ex;
     }
 }
@@ -130,11 +154,11 @@
     }
     catch (std::exception const& e) // LCOV_EXCL_LINE
     {
-        BOOST_LOG_SEV(logger(), Logger::Error) << "~RuntimeImpl(): " << e.what();
+        BOOST_LOG(logger()) << "~RuntimeImpl(): " << e.what();
     }
     catch (...) // LCOV_EXCL_LINE
     {
-        BOOST_LOG_SEV(logger(), Logger::Error) << "~RuntimeImpl(): unknown exception";
+        BOOST_LOG(logger()) << "~RuntimeImpl(): unknown exception";
     }
 }
 
@@ -293,6 +317,11 @@
     return *logger_;
 }
 
+boost::log::sources::severity_channel_logger_mt<>& RuntimeImpl::logger(Logger::Channel channel) const
+{
+    return (*logger_)(channel);
+}
+
 namespace
 {
 
@@ -411,14 +440,13 @@
             // Check if this scope has requested debug mode, if so, disable the idle timeout
             ScopeConfig scope_config(scope_ini_file);
             int idle_timeout_ms = scope_config.debug_mode() ? -1 : scope_config.idle_timeout() * 1000;
-            auto scope = unique_ptr<internal::ScopeObject>(new internal::ScopeObject(this,
-                                                                                     scope_base,
+            auto scope = unique_ptr<internal::ScopeObject>(new internal::ScopeObject(scope_base,
                                                                                      scope_config.debug_mode()));
             mw->add_scope_object(scope_id_, move(scope), idle_timeout_ms);
         }
         else
         {
-            auto scope = unique_ptr<internal::ScopeObject>(new internal::ScopeObject(this, scope_base));
+            auto scope = unique_ptr<internal::ScopeObject>(new internal::ScopeObject(scope_base));
             mw->add_scope_object(scope_id_, move(scope));
         }
 
@@ -430,7 +458,7 @@
 
         promise.set_value();
         mw->wait_for_shutdown();
-        cleanup_scope.dealloc();   // Causes ScopeBase::run() to terminate if the scope is properly written
+        cleanup_scope.dealloc();   // Causes ScopeBase::run() to return if the scope is properly written
 
         {
             // mw is now shut down, so we need a separate one to send the state update to the registry.
@@ -494,6 +522,16 @@
     }
 }
 
+string RuntimeImpl::cache_directory() const
+{
+    return find_cache_dir();
+}
+
+string RuntimeImpl::tmp_directory() const
+{
+    return find_tmp_dir();
+}
+
 string RuntimeImpl::demangled_id() const
 {
     // For scopes that are in a click package together with an app,

=== modified file 'src/scopes/internal/ScopeImpl.cpp'
--- src/scopes/internal/ScopeImpl.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/ScopeImpl.cpp	2015-01-13 07:11:02 +0000
@@ -43,12 +43,12 @@
 namespace internal
 {
 
-ScopeImpl::ScopeImpl(MWScopeProxy const& mw_proxy, RuntimeImpl* runtime, std::string const& scope_id) :
-    ObjectImpl(mw_proxy, runtime->logger()),
-    runtime_(runtime),
+ScopeImpl::ScopeImpl(MWScopeProxy const& mw_proxy, std::string const& scope_id) :
+    ObjectImpl(mw_proxy),
+    runtime_(mw_proxy->mw_base()->runtime()),
     scope_id_(scope_id)
 {
-    assert(runtime);
+    assert(runtime_);
 }
 
 ScopeImpl::~ScopeImpl()
@@ -99,7 +99,7 @@
     MWReplyProxy rp = fwd()->mw_base()->add_reply_object(ro);
 
     // "Fake" QueryCtrlProxy that doesn't have a real MWQueryCtrlProxy yet.
-    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp, runtime_->logger());
+    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp);
 
     // We pass a shared pointer to the lambda (instead of the this pointer)
     // to keep ourselves alive until after the lambda fires.
@@ -152,7 +152,7 @@
     ReplyObject::SPtr ro(make_shared<ActivationReplyObject>(reply, runtime_, to_string(), fwd()->debug_mode()));
     MWReplyProxy rp = fwd()->mw_base()->add_reply_object(ro);
 
-    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp, runtime_->logger());
+    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp);
 
     auto impl = dynamic_pointer_cast<ScopeImpl>(shared_from_this());
 
@@ -200,7 +200,7 @@
     ReplyObject::SPtr ro(make_shared<ActivationReplyObject>(reply, runtime_, to_string(), fwd()->debug_mode()));
     MWReplyProxy rp = fwd()->mw_base()->add_reply_object(ro);
 
-    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp, runtime_->logger());
+    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp);
 
     auto impl = dynamic_pointer_cast<ScopeImpl>(shared_from_this());
 
@@ -249,7 +249,7 @@
     ReplyObject::SPtr ro(make_shared<PreviewReplyObject>(reply, runtime_, to_string(), fwd()->debug_mode()));
     MWReplyProxy rp = fwd()->mw_base()->add_reply_object(ro);
 
-    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp, runtime_->logger());
+    shared_ptr<QueryCtrlImpl> ctrl = make_shared<QueryCtrlImpl>(nullptr, rp);
 
     auto impl = dynamic_pointer_cast<ScopeImpl>(shared_from_this());
 
@@ -283,9 +283,9 @@
     return ctrl;
 }
 
-ScopeProxy ScopeImpl::create(MWScopeProxy const& mw_proxy, RuntimeImpl* runtime, std::string const& scope_id)
+ScopeProxy ScopeImpl::create(MWScopeProxy const& mw_proxy, std::string const& scope_id)
 {
-    return make_shared<ScopeImpl>(mw_proxy, runtime, scope_id);
+    return make_shared<ScopeImpl>(mw_proxy, scope_id);
 }
 
 MWScopeProxy ScopeImpl::fwd()

=== modified file 'src/scopes/internal/ScopeMetadataImpl.cpp'
--- src/scopes/internal/ScopeMetadataImpl.cpp	2014-12-03 08:27:13 +0000
+++ src/scopes/internal/ScopeMetadataImpl.cpp	2015-01-13 07:11:02 +0000
@@ -499,7 +499,7 @@
     auto endpoint = it2->second.get_string();
     throw_on_empty("proxy.endpoint", endpoint);
     auto mw_proxy = mw_->create_scope_proxy(identity, endpoint);
-    proxy_ = ScopeImpl::create(mw_proxy, mw_->runtime(), scope_id_);
+    proxy_ = ScopeImpl::create(mw_proxy, scope_id_);
 
     it = find_or_throw(var, "display_name");
     display_name_ = it->second.get_string();

=== modified file 'src/scopes/internal/ScopeObject.cpp'
--- src/scopes/internal/ScopeObject.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/ScopeObject.cpp	2015-01-13 07:11:02 +0000
@@ -46,12 +46,10 @@
 namespace internal
 {
 
-ScopeObject::ScopeObject(RuntimeImpl* runtime, ScopeBase* scope_base, bool debug_mode) :
-    runtime_(runtime),
+ScopeObject::ScopeObject(ScopeBase* scope_base, bool debug_mode) :
     scope_base_(scope_base),
     debug_mode_(debug_mode)
 {
-    assert(runtime);
     assert(scope_base);
 }
 
@@ -70,7 +68,7 @@
         // to be safe, we don't assert, in case someone is running a broken client.
 
         // TODO: log error about incoming request containing an invalid reply proxy.
-        throw LogicException("Scope \"" + runtime_->scope_id() + "\": query() called with null reply proxy");
+        throw LogicException("Scope \"" + mw_base->runtime()->scope_id() + "\": query() called with null reply proxy");
     }
 
     // Ask scope to instantiate a new query.
@@ -80,16 +78,16 @@
         query_base = query_factory_fun();
         if (!query_base)
         {
-            string msg = "Scope \"" + runtime_->scope_id() + "\" returned nullptr from query_factory_fun()";
-            BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << msg;
+            string msg = "Scope \"" + mw_base->runtime()->scope_id() + "\" returned nullptr from query_factory_fun()";
+            BOOST_LOG(mw_base->runtime()->logger()) << msg;
             throw ResourceException(msg);
         }
         query_base->p->set_settings_db(scope_base_->p->settings_db());
     }
     catch (...)
     {
-        string msg = "Scope \"" + runtime_->scope_id() + "\" threw an exception from query_factory_fun()";
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error) << msg;
+        string msg = "Scope \"" + mw_base->runtime()->scope_id() + "\" threw an exception from query_factory_fun()";
+        BOOST_LOG(mw_base->runtime()->logger()) << msg;
         throw ResourceException(msg);
     }
 
@@ -127,8 +125,7 @@
         catch (...)
         {
         }
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error)
-            << "ScopeObject::query(): " << e.what();
+        BOOST_LOG(mw_base->runtime()->logger()) << "ScopeObject::query(): " << e.what();
         throw;
     }
     catch (...)
@@ -140,8 +137,7 @@
         catch (...)
         {
         }
-        BOOST_LOG_SEV(runtime_->logger(), Logger::Error)
-            << "ScopeObject::query(): unknown exception";
+        BOOST_LOG(mw_base->runtime()->logger()) << "ScopeObject::query(): unknown exception";
         throw;
     }
     return ctrl_proxy;
@@ -159,7 +155,7 @@
                  return search_query;
             },
             [&reply, &hints, this](QueryBase::SPtr query_base, MWQueryCtrlProxy ctrl_proxy) -> QueryObjectBase::SPtr {
-                return make_shared<QueryObject>(query_base, hints.cardinality(), reply, ctrl_proxy, runtime_->logger());
+                return make_shared<QueryObject>(query_base, hints.cardinality(), reply, ctrl_proxy);
             }
     );
 }
@@ -176,7 +172,7 @@
             [&reply, this](QueryBase::SPtr query_base, MWQueryCtrlProxy ctrl_proxy) -> QueryObjectBase::SPtr {
                 auto activation_base = dynamic_pointer_cast<ActivationQueryBase>(query_base);
                 assert(activation_base);
-                return make_shared<ActivationQueryObject>(activation_base, reply, ctrl_proxy, runtime_->logger());
+                return make_shared<ActivationQueryObject>(activation_base, reply, ctrl_proxy);
             }
     );
 }
@@ -195,7 +191,7 @@
             [&reply, this](QueryBase::SPtr query_base, MWQueryCtrlProxy ctrl_proxy) -> QueryObjectBase::SPtr {
                 auto activation_base = dynamic_pointer_cast<ActivationQueryBase>(query_base);
                 assert(activation_base);
-                return make_shared<ActivationQueryObject>(activation_base, reply, ctrl_proxy, runtime_->logger());
+                return make_shared<ActivationQueryObject>(activation_base, reply, ctrl_proxy);
             }
     );
 }
@@ -212,7 +208,7 @@
             [&reply, this](QueryBase::SPtr query_base, MWQueryCtrlProxy ctrl_proxy) -> QueryObjectBase::SPtr {
                 auto preview_query = dynamic_pointer_cast<PreviewQueryBase>(query_base);
                 assert(preview_query);
-                return make_shared<PreviewQueryObject>(preview_query, reply, ctrl_proxy, runtime_->logger());
+                return make_shared<PreviewQueryObject>(preview_query, reply, ctrl_proxy);
             }
     );
 }

=== modified file 'src/scopes/internal/SearchReplyImpl.cpp'
--- src/scopes/internal/SearchReplyImpl.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/SearchReplyImpl.cpp	2015-01-13 07:11:02 +0000
@@ -20,12 +20,17 @@
 #include <unity/scopes/internal/SearchReplyImpl.h>
 
 #include <unity/scopes/Annotation.h>
-#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/internal/CategorisedResultImpl.h>
 #include <unity/scopes/internal/DepartmentImpl.h>
+#include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/MWReply.h>
-#include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/QueryObjectBase.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/ScopeExceptions.h>
 #include <unity/UnityExceptions.h>
+#include <unity/util/FileIO.h>
+
+#include <stdlib.h>
 
 using namespace std;
 
@@ -39,21 +44,24 @@
 {
 
 SearchReplyImpl::SearchReplyImpl(MWReplyProxy const& mw_proxy,
-                                 std::shared_ptr<QueryObjectBase> const& qo,
+                                 shared_ptr<QueryObjectBase> const& qo,
                                  int cardinality,
-                                 std::string const& current_department_id,
-                                 boost::log::sources::severity_channel_logger_mt<>& logger)
-    : ObjectImpl(mw_proxy, logger)
-    , ReplyImpl(mw_proxy, qo, logger)
+                                 string const& query_string,
+                                 string const& current_department_id)
+    : ObjectImpl(mw_proxy)
+    , ReplyImpl(mw_proxy, qo)
     , cat_registry_(new CategoryRegistry())
     , cardinality_(cardinality)
     , num_pushes_(0)
+    , finished_(false)
+    , query_string_(query_string)
     , current_department_(current_department_id)
 {
 }
 
 SearchReplyImpl::~SearchReplyImpl()
 {
+    finished();
 }
 
 void SearchReplyImpl::register_departments(Department::SCPtr const& parent)
@@ -68,6 +76,12 @@
         throw unity::LogicException("SearchReplyImpl::register_departments(): Failed to validate departments");
     }
 
+    if (query_string_.empty())
+    {
+        lock_guard<mutex> lock(mutex_);
+        cached_departments_ = parent;
+    }
+
     ReplyImpl::push(internal::DepartmentImpl::serialize_departments(parent)); // ignore return value?
 }
 
@@ -77,10 +91,10 @@
     push(category);
 }
 
-Category::SCPtr SearchReplyImpl::register_category(std::string const& id,
-                                             std::string const& title,
-                                             std::string const &icon,
-                                             CategoryRenderer const& renderer_template)
+Category::SCPtr SearchReplyImpl::register_category(string const& id,
+                                                   string const& title,
+                                                   string const &icon,
+                                                   CategoryRenderer const& renderer_template)
 {
     // will throw if adding same category again
     auto cat = cat_registry_->register_category(id, title, icon, nullptr, renderer_template);
@@ -88,11 +102,11 @@
     return cat;
 }
 
-Category::SCPtr SearchReplyImpl::register_category(std::string const& id,
-                                             std::string const& title,
-                                             std::string const& icon,
-                                             CannedQuery const& query,
-                                             CategoryRenderer const& renderer_template)
+Category::SCPtr SearchReplyImpl::register_category(string const& id,
+                                                   string const& title,
+                                                   string const& icon,
+                                                   CannedQuery const& query,
+                                                   CategoryRenderer const& renderer_template)
 {
     // will throw if adding same category again
     auto cat = cat_registry_->register_category(id, title, icon, make_shared<CannedQuery>(query), renderer_template);
@@ -100,7 +114,7 @@
     return cat;
 }
 
-Category::SCPtr SearchReplyImpl::lookup_category(std::string const& id)
+Category::SCPtr SearchReplyImpl::lookup_category(string const& id)
 {
     return cat_registry_->lookup_category(id);
 }
@@ -128,6 +142,14 @@
         return false;
     }
 
+    // We cache the results of surfacing queries so, if a scope has not connectivity,
+    // we can replay the results of the last successful surfacing query.
+    if (query_string_.empty())
+    {
+        lock_guard<mutex> lock(mutex_);
+        cached_results_.push_back(result);
+    }
+
     // Enforce cardinality limit (0 means no limit). If the scope pushes more results
     // than requested, future pushes are ignored. push() returns false
     // on the last call that actually still pushed a result.
@@ -167,6 +189,201 @@
     return ReplyImpl::push(var);
 }
 
+void SearchReplyImpl::finished()
+{
+    if (finished_.exchange(true))
+    {
+        return;
+    }
+    write_cached_results();
+    ReplyImpl::finished();  // Upcall to deal with the normal case
+}
+
+static constexpr char const* cache_file_name = ".surfacing_cache";
+
+void SearchReplyImpl::write_cached_results() noexcept
+{
+    assert(finished_);
+
+    if (!query_string_.empty())
+    {
+        return;  // Caching applies only to surfacing queries
+    }
+
+    string tmp_path;
+    try
+    {
+        // Open a temporary file for writing.
+        tmp_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name + "XXXXXX";
+        auto opener = [tmp_path]()
+        {
+            int tmp_fd = mkstemp(const_cast<char*>(tmp_path.c_str()));
+            if (tmp_fd == -1)
+            {
+                throw FileException("cannot open tmp file " + tmp_path, errno);
+            }
+            return tmp_fd;
+        };
+        auto closer = [tmp_path](int fd)
+        {
+            if (::close(fd) == -1)
+            {
+                // LCOV_EXCL_START
+                throw FileException("cannot close tmp file " + tmp_path + " (fd = " + std::to_string(fd) + ")", errno);
+                // LCOV_EXCL_STOP
+            }
+        };
+        unity::util::ResourcePtr<int, decltype(closer)> tmp_file(opener(), closer);
+
+        // Turn departments, categories, and results into a JSON string.
+        VariantMap departments;
+        if (cached_departments_)
+        {
+            departments = cached_departments_->serialize();
+        }
+        VariantArray categories = cat_registry_->serialize();
+        VariantArray results;
+        for (auto const& r : cached_results_)
+        {
+            results.push_back(Variant(r.serialize()));
+        }
+        VariantMap vm;
+        vm["departments"] = move(departments);
+        vm["categories"] = move(categories);
+        vm["results"] = move(results);
+        string const json = Variant(move(vm)).serialize_json();
+
+        // Write tmp file.
+        if (::write(tmp_file.get(), json.c_str(), json.size()) != static_cast<int>(json.size()))
+        {
+            // LCOV_EXCL_START
+            throw FileException("cannot write tmp file " + tmp_path + " (fd = " + std::to_string(tmp_file.get()) + ")",
+                                errno);
+            // LCOV_EXCL_STOP
+        }
+        tmp_file.dealloc();  // Close tmp file.
+
+        // Atomically replace the old cache with the new one.
+        string cache_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name;
+        if (rename(tmp_path.c_str(), cache_path.c_str()) == -1)
+        {
+            throw FileException("cannot rename tmp file " + tmp_path + " to " + cache_path, errno);  // LCOV_EXCL_LINE
+        }
+    }
+    catch (std::exception const& e)
+    {
+        ::unlink(tmp_path.c_str());
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::write_cached_results(): " << e.what();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        ::unlink(tmp_path.c_str());
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::write_cached_results(): unknown exception";
+    }
+    // LCOV_EXCL_STOP
+}
+
+void SearchReplyImpl::push_surfacing_results_from_cache() noexcept
+{
+    if (!query_string_.empty())
+    {
+        return;  // Caching applies only to surfacing queries
+    }
+
+    if (finished_.exchange(true))
+    {
+        return;
+    }
+
+    string cache_path = mw_proxy_->mw_base()->runtime()->cache_directory() + "/" + cache_file_name;
+    try
+    {
+        // Read cache file.
+        string json;
+        try
+        {
+            json = unity::util::read_text_file(cache_path);
+        }
+        catch (unity::FileException const& e)
+        {
+            if (e.error() == ENOENT)
+            {
+                ReplyImpl::finished();
+                return;  // No cache has been written yet.
+            }
+            throw;
+        }
+
+        // Decode JSON for the three sections.
+        Variant v(Variant::deserialize_json(json));
+        VariantMap vm = v.get_dict();
+
+        auto it = vm.find("departments");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "departments");
+        }
+        auto department_dict = it->second.get_dict();
+
+        it = vm.find("categories");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "categories");
+        }
+        auto category_array = it->second.get_array();
+
+        it = vm.find("results");
+        if (it == vm.end())
+        {
+            throw unity::scopes::NotFoundException("malformed cache file", "results");
+        }
+        auto result_array = it->second.get_array();
+
+        // We have the JSON strings as Variants, re-create the native representations
+        // and re-instate them.
+        if (!department_dict.empty())
+        {
+            auto departments = DepartmentImpl::create(department_dict);
+            register_departments(move(departments));
+        }
+
+        for (auto const& c : category_array)
+        {
+            // Can't use make_shared here because that isn't a friend of Category.
+            auto cp = Category::SCPtr(new Category(c.get_dict()));
+            register_category(cp);
+        }
+
+        for (auto const& r : result_array)
+        {
+            VariantMap dict = r.get_dict();
+            string const cat_id = dict.at("internal").get_dict().at("cat_id").get_string();
+            auto cat = lookup_category(cat_id);
+            auto crip = new CategorisedResultImpl(move(cat), move(dict));
+            auto cr = CategorisedResult(crip);
+            push(cr);
+        }
+    }
+    catch (std::exception const& e)
+    {
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): " << e.what();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        BOOST_LOG(mw_proxy_->mw_base()->runtime()->logger())
+            << "SearchReply::push_surfacing_results_from_cache() (file = " + cache_path + "): unknown exception";
+    }
+    // LCOV_EXCL_STOP
+
+    // Query is complete.
+    ReplyImpl::finished();
+}
+
 } // namespace internal
 
 } // namespace scopes

=== modified file 'src/scopes/internal/SettingsDB.cpp'
--- src/scopes/internal/SettingsDB.cpp	2014-12-02 04:18:44 +0000
+++ src/scopes/internal/SettingsDB.cpp	2015-01-13 07:11:02 +0000
@@ -184,8 +184,6 @@
 #pragma GCC diagnostic pop
 
         int bytes_avail = 0;
-        static_assert(std::alignment_of<char*>::value >= std::alignment_of<struct inotify_event>::value,
-                      "cannot use std::string as buffer for inotify events");
         string buffer;
 
         // Poll for notifications until stop is requested
@@ -230,7 +228,12 @@
             int i = 0;
             while (i < bytes_read)
             {
+                static_assert(std::alignment_of<char*>::value >= std::alignment_of<struct inotify_event>::value,
+                              "cannot use std::string as buffer for inotify events");
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
                 auto event = reinterpret_cast<inotify_event const*>(&buffer[i]);
+#pragma GCC diagnostic pop
 
                 if (event->mask & IN_DELETE_SELF)
                 {
@@ -262,13 +265,13 @@
     }
     catch (exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SettingsDB::watch_thread(): Thread aborted: " << e.what();
+        BOOST_LOG(logger_) << "SettingsDB::watch_thread(): Thread aborted: " << e.what();
         lock_guard<mutex> lock(mutex_);
         thread_state_ = Failed;
     }
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SettingsDB::watch_thread(): Thread aborted: unknown exception";
+        BOOST_LOG(logger_) << "SettingsDB::watch_thread(): Thread aborted: unknown exception";
         lock_guard<mutex> lock(mutex_);
         thread_state_ = Failed;
     }
@@ -337,9 +340,9 @@
                                            | IN_DELETE_SELF));
             if (watch_.get() < 0)
             {
-                throw ResourceException("SettingsDB::add_watch(): failed to add watch for path: \"" +
-                                        db_path_ + "\". inotify_add_watch() failed. (fd = " +
-                                        to_string(fd_.get()) + ", path = " + db_path_ + ")");
+                throw SyscallException("SettingsDB::add_watch(): failed to add watch for path: \"" +
+                                       db_path_ + "\". inotify_add_watch() failed. (fd = " +
+                                       to_string(fd_.get()) + ", path = " + db_path_ + ")", errno);
             }
 
             state_changed_ = true;

=== modified file 'src/scopes/internal/smartscopes/SSQueryObject.cpp'
--- src/scopes/internal/smartscopes/SSQueryObject.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/smartscopes/SSQueryObject.cpp	2015-01-13 07:11:02 +0000
@@ -19,8 +19,10 @@
 #include <unity/scopes/internal/smartscopes/SSQueryObject.h>
 
 #include <unity/scopes/ActivationQueryBase.h>
+#include <unity/scopes/internal/InvokeInfo.h>
 #include <unity/scopes/internal/MWReply.h>
 #include <unity/scopes/internal/PreviewReplyImpl.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/internal/SearchReplyImpl.h>
 #include <unity/scopes/PreviewQueryBase.h>
 #include <unity/scopes/PreviewReply.h>
@@ -46,8 +48,7 @@
 namespace smartscopes
 {
 
-SSQueryObject::SSQueryObject(boost::log::sources::severity_channel_logger_mt<>& logger)
-    : logger_(logger)
+SSQueryObject::SSQueryObject()
 {
 }
 
@@ -55,7 +56,7 @@
 {
 }
 
-void SSQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& /*info*/) noexcept
+void SSQueryObject::run(MWReplyProxy const& reply, InvokeInfo const& info) noexcept
 {
     decltype(queries_.begin()) query_it;
 
@@ -94,7 +95,7 @@
         std::lock_guard<std::mutex> lock(queries_mutex_);
 
         query_it->second->q_pushable = false;
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SSQueryObject::run(): " << e.what();
+        BOOST_LOG(info.mw->runtime()->logger()) << "SSQueryObject::run(): " << e.what();
         reply->finished(CompletionDetails(CompletionDetails::Error, e.what()));  // Oneway, can't block
     }
     catch (...)
@@ -102,7 +103,7 @@
         std::lock_guard<std::mutex> lock(queries_mutex_);
 
         query_it->second->q_pushable = false;
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SSQueryObject::run(): unknown exception";
+        BOOST_LOG(info.mw->runtime()->logger()) << "SSQueryObject::run(): unknown exception";
         reply->finished(CompletionDetails(CompletionDetails::Error, "unknown exception"));  // Oneway, can't block
     }
 
@@ -206,8 +207,8 @@
     q_reply_proxy = make_shared<SearchReplyImpl>(reply,
                                                  shared_from_this(),
                                                  query->q_cardinality,
-                                                 q_base->department_id(),
-                                                 logger_);
+                                                 q_base->query().query_string(),
+                                                 q_base->department_id());
     assert(q_reply_proxy);
     query->q_reply_proxy = q_reply_proxy;
 
@@ -229,7 +230,7 @@
 
     // Create the reply proxy and keep a weak_ptr, which we will need
     // if cancel() is called later.
-    q_reply_proxy = make_shared<PreviewReplyImpl>(reply, shared_from_this(), logger_);
+    q_reply_proxy = make_shared<PreviewReplyImpl>(reply, shared_from_this());
     assert(q_reply_proxy);
     query->q_reply_proxy = q_reply_proxy;
 

=== modified file 'src/scopes/internal/smartscopes/SSRegistryObject.cpp'
--- src/scopes/internal/smartscopes/SSRegistryObject.cpp	2014-12-03 06:53:40 +0000
+++ src/scopes/internal/smartscopes/SSRegistryObject.cpp	2015-01-13 07:11:02 +0000
@@ -50,7 +50,7 @@
     : ssclient_(std::make_shared<SmartScopesClient>(
                     std::make_shared<HttpClientQt>(ss_config.http_reply_timeout() * 1000),  // need millisecs
                     std::make_shared<JsonCppNode>(),
-                    middleware->runtime()->logger(),
+                    middleware->runtime(),
                     sss_url))
     , refresh_stopped_(false)
     , middleware_(middleware)
@@ -82,8 +82,7 @@
     catch (std::exception const& e)
     {
 
-        BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
-            << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
+        BOOST_LOG(middleware_->runtime()->logger()) << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
     }
 
     refresh_thread_ = std::thread(&SSRegistryObject::refresh_thread, this);
@@ -96,7 +95,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
+            BOOST_LOG(middleware_->runtime()->logger())
                 << "SSRegistryObject(): failed to create registry publisher: " << e.what();
         }
     }
@@ -210,7 +209,7 @@
             }
             catch (std::exception const& e)
             {
-                BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
+                BOOST_LOG(middleware_->runtime()->logger())
                     << "SSRegistryObject: get_remote_scopes() failed: " << e.what();
             }
         }
@@ -284,7 +283,7 @@
                 }
                 catch (ResourceException const& e)
                 {
-                    BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
+                    BOOST_LOG(middleware_->runtime()->logger())
                         << "SSRegistryObject: ignoring invalid settings JSON for scope \"" << scope.id << "\": "
                         << e.what();
                 }
@@ -333,7 +332,7 @@
                 }
                 catch (ResourceException const& e)
                 {
-                    BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
+                    BOOST_LOG(middleware_->runtime()->logger())
                         << "SSRegistryObject: ignoring invalid settings JSON for scope \"" << scope.id << "\": "
                         << e.what();
                 }
@@ -348,7 +347,6 @@
             metadata->set_keywords(scope.keywords);
 
             ScopeProxy proxy = ScopeImpl::create(middleware_->create_scope_proxy(scope.id, ss_scope_endpoint_),
-                                                 middleware_->runtime(),
                                                  scope.id);
 
             metadata->set_proxy(proxy);
@@ -360,7 +358,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(middleware_->runtime()->logger(), Logger::Error)
+            BOOST_LOG(middleware_->runtime()->logger())
                 << "SSRegistryObject: skipping scope \"" << scope.id << "\": " << e.what();
         }
     }

=== modified file 'src/scopes/internal/smartscopes/SSScopeObject.cpp'
--- src/scopes/internal/smartscopes/SSScopeObject.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/smartscopes/SSScopeObject.cpp	2015-01-13 07:11:02 +0000
@@ -45,10 +45,9 @@
                              SSRegistryObject::SPtr ss_registry)
     : ss_scope_id_(ss_scope_id)
     , co_(std::make_shared<SSQueryCtrlObject>())
-    , qo_(std::make_shared<SSQueryObject>(middleware->runtime()->logger()))
+    , qo_(std::make_shared<SSQueryObject>())
     , smartscope_(new SmartScope(ss_registry))
     , ss_registry_(ss_registry)
-    , logger_(middleware->runtime()->logger())
 {
     // Connect the query ctrl to the middleware.
     middleware->add_dflt_query_ctrl_object(co_);
@@ -173,7 +172,7 @@
         catch (...)
         {
         }
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SSScopeObject::query(): " << e.what();
+        BOOST_LOG(info.mw->runtime()->logger()) << "SSScopeObject::query(): " << e.what();
         throw;
     }
     catch (...)
@@ -185,7 +184,7 @@
         catch (...)
         {
         }
-        BOOST_LOG_SEV(logger_, Logger::Error) << "SSScopeObject::query(): unknown exception";
+        BOOST_LOG(info.mw->runtime()->logger()) << "SSScopeObject::query(): unknown exception";
         throw;
     }
 

=== modified file 'src/scopes/internal/smartscopes/SmartScope.cpp'
--- src/scopes/internal/smartscopes/SmartScope.cpp	2014-12-01 08:26:52 +0000
+++ src/scopes/internal/smartscopes/SmartScope.cpp	2015-01-13 07:11:02 +0000
@@ -19,6 +19,7 @@
 
 #include <unity/scopes/internal/smartscopes/SmartScope.h>
 
+#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/PreviewReply.h>
 #include <unity/scopes/SearchReply.h>
 
@@ -105,7 +106,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(ss_client_->logger(), Logger::Error)
+            BOOST_LOG(ss_client_->logger())
                 << "SmartScope::run(): Failed to register filters for scope '" << filters_data.scope_id
                 << "': " << e.what();
         }
@@ -117,7 +118,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(ss_client_->logger(), Logger::Error)
+            BOOST_LOG(ss_client_->logger())
                 << "SmartScope::run(): Failed to set filter state for scope '" << filters_data.scope_id
                 << "': " << e.what();
         }
@@ -130,7 +131,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Error)
+            BOOST_LOG(this->ss_client_->logger())
                 << "SmartScope: failed to register category: \"" << category->id
                 << "\" for scope \"" << scope_id_ << "\" and query: \"" << query_.query_string() << "\"";
         }
@@ -153,7 +154,7 @@
         }
         else
         {
-            BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Error)
+            BOOST_LOG(this->ss_client_->logger())
                 << "SmartScope: result for query: \"" << scope_id_ << "\": \"" << query_.query_string()
                 << "\" returned an invalid cat_id. Skipping result.";
         }
@@ -166,7 +167,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(this->ss_client_->logger(), Logger::Error)
+            BOOST_LOG(this->ss_client_->logger())
                 << "SmartScope::run(): Failed to register departments for scope '" << scope_id_ << "': " << e.what();
         }
     };

=== modified file 'src/scopes/internal/smartscopes/SmartScopesClient.cpp'
--- src/scopes/internal/smartscopes/SmartScopesClient.cpp	2014-12-11 16:11:16 +0000
+++ src/scopes/internal/smartscopes/SmartScopesClient.cpp	2015-01-13 07:11:02 +0000
@@ -19,6 +19,7 @@
 
 #include <unity/scopes/internal/FilterBaseImpl.h>
 #include <unity/scopes/internal/FilterStateImpl.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
 #include <unity/scopes/internal/smartscopes/SmartScopesClient.h>
 
 #include <unity/scopes/ScopeExceptions.h>
@@ -54,6 +55,9 @@
 static const std::string c_scopes_cache_filename = "remote-scopes.json";
 static const std::string c_partner_id_file = "/custom/partner-id";
 
+// Some of the tests don't have a runtime, so we use a separate logger in that case.
+BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(test_logger, boost::log::sources::severity_channel_logger_mt<>)
+
 using namespace unity::scopes;
 using namespace unity::scopes::internal::smartscopes;
 
@@ -107,12 +111,13 @@
 
 SmartScopesClient::SmartScopesClient(HttpClientInterface::SPtr http_client,
                                      JsonNodeInterface::SPtr json_node,
-                                     boost::log::sources::severity_channel_logger_mt<>& logger,
+                                     RuntimeImpl* runtime,
                                      std::string const& url,
                                      std::string const& partner_id_path)
     : http_client_(http_client)
     , json_node_(json_node)
-    , logger_(logger)
+    , runtime_(runtime)
+    , logger_(runtime ? runtime->logger() : test_logger::get())
     , have_latest_cache_(false)
     , query_counter_(0)
     , partner_file_(partner_id_path)
@@ -205,14 +210,13 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "SmartScopesClient.get_remote_scopes(): Failed to retrieve remote scopes from uri: "
             << url_ << c_remote_scopes_resource << ": " << e.what();
 
         if (caching_enabled)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
-                << "SmartScopesClient.get_remote_scopes(): Using remote scopes from cache";
+            BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Using remote scopes from cache";
 
             response_str = read_cache();
             if (response_str.empty())
@@ -239,9 +243,8 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
-            << "SmartScopesClient.get_remote_scopes() Failed to parse json response from uri: "
-            << url_ << c_remote_scopes_resource << ": " << e.what();
+        BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes() Failed to parse json response from uri: "
+                           << url_ << c_remote_scopes_resource << ": " << e.what();
         throw;
     }
 
@@ -256,8 +259,7 @@
 
             if (!child_node->has_node("id"))
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
-                    << "SmartScopesClient.get_remote_scopes(): Skipping scope with no id";
+                BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Skipping scope with no id";
                 continue;
             }
 
@@ -269,7 +271,7 @@
             {
                 if (!child_node->has_node(field))
                 {
-                    BOOST_LOG_SEV(logger_, Logger::Error)
+                    BOOST_LOG(logger_)
                         << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
                         << "\" has no \"" << field << "\" field";
                     err = true;
@@ -277,8 +279,7 @@
             }
             if (err)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
-                    << "SmartScopesClient.get_remote_scopes(): Skipping scope: \"" << scope.id << "\"";
+                BOOST_LOG(logger_) << "SmartScopesClient.get_remote_scopes(): Skipping scope: \"" << scope.id << "\"";
                 continue;
             }
 
@@ -317,11 +318,9 @@
             scope.version = child_node->has_node("version") ? child_node->get_node("version")->as_int() : 0;
             if (scope.version < 0)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
-                    << "\" returned a negative \"version\" value";
-                BOOST_LOG_SEV(logger_, Logger::Error)
-                    << "SmartScopesClient.get_remote_scopes(): Skipping scope: \"" << scope.id << "\"";
+                    << "\" returned a negative \"version\" value, skipping scope";
                 continue;
             }
 
@@ -339,7 +338,7 @@
                         }
                         catch (unity::LogicException const& e)
                         {
-                            BOOST_LOG_SEV(logger_, Logger::Error)
+                            BOOST_LOG(logger_)
                                 << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
                                 << "\" returned a non-string keyword";
                         }
@@ -347,7 +346,7 @@
                 }
                 else
                 {
-                    BOOST_LOG_SEV(logger_, Logger::Error)
+                    BOOST_LOG(logger_)
                         << "SmartScopesClient.get_remote_scopes(): Scope: \"" << scope.id
                         << "\" returned an invalid value type for \"keywords\"";
                 }
@@ -357,7 +356,7 @@
         }
         catch (std::exception const& e)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "SmartScopesClient.get_remote_scopes(): Skipping scope: \""
                 << scope.id << "\" due to a json parsing failure: " << e.what();
         }
@@ -365,7 +364,7 @@
 
     if (remote_scopes.empty())
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "SmartScopesClient.get_remote_scopes(): No valid remote scopes retrieved from uri: "
             << url_ << c_remote_scopes_resource;
     }
@@ -379,7 +378,7 @@
             }
             catch (std::exception const& e)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "SmartScopesClient.get_remote_scopes(): Failed to write to cache file: "
                     << c_scopes_cache_dir << c_scopes_cache_filename << ": " << e.what();
             }
@@ -477,7 +476,7 @@
             }
             catch (std::exception const &e)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error) << "SmartScopesClient.search(): Failed to parse: " << e.what();
+                BOOST_LOG(logger_) << "SmartScopesClient.search(): Failed to parse: " << e.what();
             }
     }, headers);
 
@@ -541,18 +540,13 @@
             }
             catch (std::exception const &e)
             {
-                BOOST_LOG_SEV(logger_, Logger::Error) << "SmartScopesClient.preview(): Failed to parse: " << e.what();
+                BOOST_LOG(logger_) << "SmartScopesClient.preview(): Failed to parse: " << e.what();
             }
     }, headers);
 
     return PreviewHandle::UPtr(new PreviewHandle(preview_id, shared_from_this()));
 }
 
-boost::log::sources::severity_channel_logger_mt<>& SmartScopesClient::logger() const
-{
-    return logger_;
-}
-
 void SmartScopesClient::parse_line(std::string const& json, PreviewReplyHandler const& handler)
 {
     JsonNodeInterface::SPtr root_node;
@@ -703,7 +697,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "SmartScopesClient.get_search_results(): Failed to retrieve search results for query "
             << search_id << ": " << e.what();
         throw;
@@ -752,7 +746,7 @@
             catch (std::exception const& e)
             {
                 // error in one subdepartment is not critical - just ignore it
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger_)
                     << "SmartScopesClient::parse_departments(): Error parsing subdepartment of department '"
                     << dep->label << "': " << e.what();
             }
@@ -809,7 +803,7 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error)
+        BOOST_LOG(logger_)
             << "SmartScopesClient.get_preview_results(): Failed to retrieve preview results for query "
             << preview_id;
         throw;
@@ -925,7 +919,7 @@
             setting_valid = true;
             break;
         default:
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "SmartScopesClient.stringify_settings(): Ignoring unsupported Variant type for settings value: \""
                 << setting.first << "\"";
         }
@@ -946,3 +940,8 @@
     }
     return result_str.str();
 }
+
+boost::log::sources::severity_channel_logger_mt<>& SmartScopesClient::logger() const
+{
+    return logger_;
+}

=== modified file 'src/scopes/internal/zmq_middleware/ObjectAdapter.cpp'
--- src/scopes/internal/zmq_middleware/ObjectAdapter.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/zmq_middleware/ObjectAdapter.cpp	2015-01-13 07:11:02 +0000
@@ -56,11 +56,17 @@
 
 char const* pump_suffix = "-pump";
 
+// Some tests use a nullptr for the run time, so we use different loggers in that case.
+
+BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(oa_test_logger, boost::log::sources::severity_channel_logger_mt<>)
+
+BOOST_LOG_INLINE_GLOBAL_LOGGER_CTOR_ARGS(
+    oa_test_ipc_logger,
+    boost::log::sources::severity_channel_logger_mt<>,
+    ((boost::log::keywords::severity = Logger::Trace, boost::log::keywords::channel = "IPC")))
+
 }  // namespace
 
-// Some tests use a nullptr for the run time, so we use a different logger in that case.
-BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(object_adapter_test_logger, boost::log::sources::severity_channel_logger_mt<>)
-
 ObjectAdapter::ObjectAdapter(ZmqMiddleware& mw, string const& name, string const& endpoint, RequestMode m,
                              int pool_size, int64_t idle_timeout) :
     mw_(mw),
@@ -69,8 +75,7 @@
     mode_(m),
     pool_size_(pool_size),
     idle_timeout_(idle_timeout != -1 ? idle_timeout : zmqpp::poller::wait_forever),
-    state_(Inactive),
-    logger_(mw.runtime() ? mw.runtime()->logger() : object_adapter_test_logger::get())
+    state_(Inactive)
 {
     assert(!name.empty());
     assert(!endpoint.empty());
@@ -86,12 +91,12 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ObjectAdapter(): exception from shutdown(): " << e.what();
+        BOOST_LOG(logger()) << "~ObjectAdapter(): exception from shutdown(): " << e.what();
     }
     // LCOV_EXCL_START
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ObjectAdapter(): unknown exception from shutdown()";
+        BOOST_LOG(logger()) << "~ObjectAdapter(): unknown exception from shutdown()";
     }
     // LCOV_EXCL_STOP
 
@@ -103,12 +108,12 @@
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ObjectAdapter(): exception from wait_for_shutdown(): " << e.what();
+        BOOST_LOG(logger()) << "~ObjectAdapter(): exception from wait_for_shutdown(): " << e.what();
     }
     // LCOV_EXCL_START
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ObjectAdapter(): unknown exception from wait_for_shutdown()";
+        BOOST_LOG(logger()) << "~ObjectAdapter(): unknown exception from wait_for_shutdown()";
     }
     // LCOV_EXCL_STOP
 }
@@ -729,7 +734,7 @@
             }
             else
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger())
                     << "ObjectAdapter: invalid oneway message header "
                      << "(id: " << current.id << ", adapter: " << name_ << ", op: " << current.op_name << ")";
             }
@@ -751,7 +756,7 @@
             }
             else
             {
-                BOOST_LOG_SEV(logger_, Logger::Error)
+                BOOST_LOG(logger())
                     << "ObjectAdapter: twoway invocation sent to oneway adapter "
                     << "(id: " << current.id << ", adapter: " << name_ << ", op: " << current.op_name << ")";
             }
@@ -774,7 +779,7 @@
         }
         else
         {
-            BOOST_LOG_SEV(logger_, Logger::Error) << s.str();
+            BOOST_LOG(logger()) << s.str();
         }
         return;
     }
@@ -800,6 +805,12 @@
             auto exr = create_object_not_exist_response(b, current);
             sender.send(exr);
         }
+        else
+        {
+            BOOST_LOG_SEV(logger(), Logger::Warning)
+                << "ObjectAdapter: no servant for oneway request "
+                << "(id: " << current.id << ", adapter: " << name_ << ", op: " << current.op_name << ")";
+        }
         return;
     }
 
@@ -808,9 +819,11 @@
     auto in_params = req.getInParams();
     capnp::MallocMessageBuilder b;
     auto r = b.initRoot<capnproto::Response>();
+    trace_dispatch(current);
     servant->safe_dispatch_(current, in_params, r); // noexcept
     if (mode_ == RequestMode::Twoway)
     {
+        BOOST_LOG(ipc_logger()) << decode_status(b.getRoot<capnproto::Response>());
         pump.send(client_address, zmqpp::socket::send_more);
         pump.send("", zmqpp::socket::send_more);
         sender.send(b.getSegmentsForOutput());
@@ -853,6 +866,26 @@
     state_changed_.notify_all();
 }
 
+boost::log::sources::severity_channel_logger_mt<>& ObjectAdapter::logger() const
+{
+    return mw_.runtime() ? mw_.runtime()->logger() : oa_test_logger::get();
+}
+
+boost::log::sources::severity_channel_logger_mt<>& ObjectAdapter::ipc_logger() const
+{
+    return mw_.runtime() ? mw_.runtime()->logger(Logger::Channel::IPC) : oa_test_ipc_logger::get();
+}
+
+void ObjectAdapter::trace_dispatch(Current const& c)
+{
+    BOOST_LOG(ipc_logger())
+        << "received request: "
+        << "op = " << c.op_name
+        << ", id = " << c.id
+        << ", cat = " << c.category
+        << ", mode = " << (mode_ == RequestMode::Oneway ? "oneway" : "twoway");
+}
+
 } // namespace zmq_middleware
 
 } // namespace internal

=== modified file 'src/scopes/internal/zmq_middleware/ZmqException.cpp'
--- src/scopes/internal/zmq_middleware/ZmqException.cpp	2014-09-08 05:55:39 +0000
+++ src/scopes/internal/zmq_middleware/ZmqException.cpp	2015-01-13 07:11:02 +0000
@@ -123,9 +123,58 @@
         {
             throw MiddlewareException(payload.getUnknown().cStr());
         }
-        default:
-            break;
-    }
+        // LCOV_EXCL_START
+        default:
+        {
+            assert(false);
+        }
+        // LCOV_EXCL_STOP
+    }
+}
+
+string decode_runtime_exception(capnproto::Response::Reader const& response)
+{
+    assert(response.getStatus() == capnproto::ResponseStatus::RUNTIME_EXCEPTION);
+
+    try
+    {
+        throw_if_runtime_exception(response);
+        return "";  // LCOV_EXCL_LINE (not reached, dummy return to prevent compiler warning
+    }
+    catch (MiddlewareException const& e)
+    {
+        return e.what();
+    }
+}
+
+string decode_status(capnproto::Response::Reader const& response)
+{
+    string s;
+    switch (response.getStatus())
+    {
+        case capnproto::ResponseStatus::SUCCESS:
+        {
+            s = "status = Success";
+            break;
+        }
+        case capnproto::ResponseStatus::USER_EXCEPTION:
+        {
+            s = "status = User exception";
+            break;
+        }
+        case capnproto::ResponseStatus::RUNTIME_EXCEPTION:
+        {
+            s = decode_runtime_exception(response);
+            break;
+        }
+        // LCOV_EXCL_START
+        default:
+        {
+            assert(false);
+        }
+        // LCOV_EXCL_STOP
+    }
+    return s;
 }
 
 } // namespace zmq_middleware

=== modified file 'src/scopes/internal/zmq_middleware/ZmqMiddleware.cpp'
--- src/scopes/internal/zmq_middleware/ZmqMiddleware.cpp	2014-12-04 03:33:59 +0000
+++ src/scopes/internal/zmq_middleware/ZmqMiddleware.cpp	2015-01-13 07:11:02 +0000
@@ -166,18 +166,18 @@
         auto millisecs = chrono::duration_cast<chrono::milliseconds>(end_time - start_time).count();
         if (millisecs > 100)
         {
-            BOOST_LOG_SEV(logger_, Logger::Error)
+            BOOST_LOG(logger_)
                 << "warning: ~ZmqMiddleware(): context_.terminate() took " << millisecs
                 << " ms to complete for " << server_name_;
         }
     }
     catch (std::exception const& e)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ZmqMiddleware(): " << e.what();
+        BOOST_LOG(logger_) << "~ZmqMiddleware(): " << e.what();
     }
     catch (...)
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "~ZmqMiddleware(): unknown exception";
+        BOOST_LOG(logger_) << "~ZmqMiddleware(): unknown exception";
     }
 }
 
@@ -559,7 +559,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_query_ctrl_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_query_ctrl_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -579,7 +579,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_dflt_query_ctrl_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_dflt_query_ctrl_object(): " << e.what();
         throw;
     }
 }
@@ -601,7 +601,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_query_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_query_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -621,7 +621,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_dflt_query_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_dflt_query_object(): " << e.what();
         throw;
     }
 }
@@ -645,7 +645,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_registry_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_registry_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -668,7 +668,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_reply_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_reply_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -692,7 +692,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_scope_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_scope_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -712,7 +712,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_dflt_scope_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_dflt_scope_object(): " << e.what();
         throw;
     }
 }
@@ -737,7 +737,7 @@
     }
     catch (std::exception const& e)  // Can happen during shutdown
     {
-        BOOST_LOG_SEV(logger_, Logger::Error) << "exception in add_state_receiver_object(): " << e.what();
+        BOOST_LOG(logger_) << "exception in add_state_receiver_object(): " << e.what();
         throw;
     }
     return proxy;
@@ -826,12 +826,12 @@
     if (category == scope_category)
     {
         auto p = make_shared<ZmqScope>(this, endpoint, identity, category, timeout);
-        return ScopeImpl::create(p, runtime(), identity);
+        return ScopeImpl::create(p, identity);
     }
     else if (category == registry_category)
     {
         auto p = make_shared<ZmqRegistry>(this, endpoint, identity, category, timeout);
-        return make_shared<RegistryImpl>(p, runtime());
+        return make_shared<RegistryImpl>(p);
     }
     else
     {

=== modified file 'src/scopes/internal/zmq_middleware/ZmqObject.cpp'
--- src/scopes/internal/zmq_middleware/ZmqObject.cpp	2014-11-14 07:06:23 +0000
+++ src/scopes/internal/zmq_middleware/ZmqObject.cpp	2015-01-13 07:11:02 +0000
@@ -166,23 +166,9 @@
     return request;
 }
 
-#ifdef ENABLE_IPC_MONITOR
-void register_monitor_socket(ConnectionPool& pool, zmqpp::context_t const& context)
-{
-    thread_local static bool monitor_initialized = false;
-    if (!monitor_initialized) {
-        monitor_initialized = true;
-        auto monitor_socket = make_shared<zmqpp::socket>(context, zmqpp::socket_type::publish);
-        monitor_socket->set(zmqpp::socket_option::linger, 0);
-        monitor_socket->connect(MONITOR_ENDPOINT);
-        pool.register_socket(MONITOR_ENDPOINT, monitor_socket, false);
-    }
-}
-#endif
-
 // Get a socket to the endpoint for this proxy and write the request on the wire.
 
-void ZmqObjectProxy::invoke_oneway_(capnp::MessageBuilder& in_params)
+void ZmqObjectProxy::invoke_oneway_(capnp::MessageBuilder& request)
 {
     // Each calling thread gets its own pool because zmq sockets are not thread-safe.
     thread_local static ConnectionPool pool(*mw_base()->context());
@@ -192,30 +178,22 @@
     assert(mode_ == RequestMode::Oneway);
     shared_ptr<zmqpp::socket> s = pool.find(endpoint_);
     ZmqSender sender(*s);
-    auto segments = in_params.getSegmentsForOutput();
+    auto segments = request.getSegmentsForOutput();
+    trace_request_(request);
     if (!sender.send(segments, ZmqSender::DontWait))
     {
         // If there is nothing at the other end, discard the message and trash the socket.
         pool.remove(endpoint_);
         return;
     }
-
-#ifdef ENABLE_IPC_MONITOR
-    if (true) {
-        register_monitor_socket(pool, *mw_base()->context());
-        auto monitor = pool.find(MONITOR_ENDPOINT);
-        auto word_arr = capnp::messageToFlatArray(segments);
-        monitor->send_raw(reinterpret_cast<char*>(&word_arr[0]), word_arr.size() * sizeof(capnp::word));
-    }
-#endif
 }
 
-ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway_(capnp::MessageBuilder& in_params)
+ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway_(capnp::MessageBuilder& request)
 {
-    return invoke_twoway_(in_params, timeout_);
+    return invoke_twoway_(request, timeout_);
 }
 
-ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway_(capnp::MessageBuilder& in_params,
+ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway_(capnp::MessageBuilder& request,
                                                                int64_t twoway_timeout,
                                                                int64_t locate_timeout)
 {
@@ -263,14 +241,14 @@
     }
 
     // Try the invocation
-    return invoke_twoway__(in_params, twoway_timeout);
+    return invoke_twoway__(request, twoway_timeout);
 }
 
 // Get a socket to the endpoint for this proxy and write the request on the wire.
 // Poll for the reply with the given timeout.
 // Return a reader for the response or throw if the timeout expires.
 
-ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway__(capnp::MessageBuilder& in_params, int64_t timeout)
+ZmqObjectProxy::TwowayOutParams ZmqObjectProxy::invoke_twoway__(capnp::MessageBuilder& request, int64_t timeout)
 {
     RequestMode mode;
     std::string endpoint;
@@ -295,21 +273,10 @@
     s.set(zmqpp::socket_option::reconnect_interval_max, reconnect_max);
     s.connect(endpoint);
     ZmqSender sender(s);
-    auto segments = in_params.getSegmentsForOutput();
+    auto segments = request.getSegmentsForOutput();
+    trace_request_(request);
     sender.send(segments);
 
-#ifdef ENABLE_IPC_MONITOR
-    // Each calling thread gets its own pool because zmq sockets are not thread-safe.
-    thread_local static ConnectionPool pool(*mw_base()->context());
-
-    if (true) {
-        register_monitor_socket(pool, *mw_base()->context());
-        auto monitor = pool.find(MONITOR_ENDPOINT);
-        auto word_arr = capnp::messageToFlatArray(segments);
-        monitor->send_raw(reinterpret_cast<char*>(&word_arr[0]), word_arr.size() * sizeof(capnp::word));
-    }
-#endif
-
     zmqpp::poller p;
     p.add(s);
 
@@ -324,7 +291,7 @@
 
     if (!p.has_input(s))
     {
-        string op_name = in_params.getRoot<capnproto::Request>().getOpName().cStr();
+        string op_name = request.getRoot<capnproto::Request>().getOpName().cStr();
         throw TimeoutException("Request timed out after " + std::to_string(timeout) + " milliseconds (endpoint = " +
                                endpoint + ", op = " + op_name + ")");
     }
@@ -335,10 +302,46 @@
     out_params.receiver.reset(new ZmqReceiver(s));
     auto params = out_params.receiver->receive();
     out_params.reader.reset(new capnp::SegmentArrayMessageReader(params));
+    trace_reply_(request, *out_params.reader);
     return out_params;
     // Outgoing twoway socket closed here.
 }
 
+string ZmqObjectProxy::decode_request_(capnp::MessageBuilder& request)
+{
+    auto r = request.getRoot<capnproto::Request>();
+    auto mode = r.getMode();
+    auto op_name = r.getOpName().cStr();
+    auto identity = r.getId().cStr();
+    auto cat = r.getCat().cStr();
+    stringstream s;
+    s << "op = " << op_name
+      << ", id = " << identity
+      << ", cat = " << cat
+      << ", mode = " << (mode == capnproto::RequestMode::ONEWAY ? "oneway" : "twoway");
+    return s.str();
+}
+
+void ZmqObjectProxy::trace_request_(capnp::MessageBuilder& request)
+{
+    BOOST_LOG(mw_base()->runtime()->logger(Logger::IPC))
+        << "sending request: "
+        << decode_request_(request);
+}
+
+string ZmqObjectProxy::decode_reply_(capnp::MessageBuilder& request, capnp::MessageReader& reply)
+{
+    auto response = reply.getRoot<capnproto::Response>();
+    return decode_request_(request) + ", " + decode_status(response);
+}
+
+void ZmqObjectProxy::trace_reply_(capnp::MessageBuilder& request, capnp::MessageReader& reply)
+{
+    BOOST_LOG(mw_base()->runtime()->logger(Logger::IPC))
+        << "received reply: "
+        << decode_reply_(request, reply);
+}
+
 } // namespace zmq_middleware
 
 } // namespace internal

=== modified file 'src/scopes/internal/zmq_middleware/ZmqRegistry.cpp'
--- src/scopes/internal/zmq_middleware/ZmqRegistry.cpp	2014-11-14 07:04:55 +0000
+++ src/scopes/internal/zmq_middleware/ZmqRegistry.cpp	2015-01-13 07:11:02 +0000
@@ -167,7 +167,7 @@
                                                    proxy.getIdentity(),
                                                    proxy.getCategory(),
                                                    proxy.getTimeout());
-            return ScopeImpl::create(zmq_proxy, mw->runtime(), identity);
+            return ScopeImpl::create(zmq_proxy, identity);
         }
         case capnproto::Registry::LocateResponse::Response::NOT_FOUND_EXCEPTION:
         {

=== modified file 'src/scopes/internal/zmq_middleware/ZmqScope.cpp'
--- src/scopes/internal/zmq_middleware/ZmqScope.cpp	2014-11-20 05:29:23 +0000
+++ src/scopes/internal/zmq_middleware/ZmqScope.cpp	2015-01-13 07:11:02 +0000
@@ -18,7 +18,6 @@
 
 #include <unity/scopes/internal/zmq_middleware/ZmqScope.h>
 
-#include <unity/scopes/internal/Logger.h>
 #include <unity/scopes/internal/QueryCtrlImpl.h>
 #include <unity/scopes/internal/RuntimeImpl.h>
 #include <scopes/internal/zmq_middleware/capnproto/Scope.capnp.h>
@@ -105,7 +104,7 @@
                                          proxy.getEndpoint().cStr(),
                                          proxy.getIdentity().cStr(),
                                          proxy.getCategory().cStr()));
-    return make_shared<QueryCtrlImpl>(p, reply_proxy, mw_base()->runtime()->logger());
+    return make_shared<QueryCtrlImpl>(p, reply_proxy);
 }
 
 QueryCtrlProxy ZmqScope::activate(VariantMap const& result, VariantMap const& hints, MWReplyProxy const& reply)
@@ -135,7 +134,7 @@
                                          proxy.getEndpoint().cStr(),
                                          proxy.getIdentity().cStr(),
                                          proxy.getCategory().cStr()));
-    return make_shared<QueryCtrlImpl>(p, reply_proxy, mw_base()->runtime()->logger());
+    return make_shared<QueryCtrlImpl>(p, reply_proxy);
 }
 
 QueryCtrlProxy ZmqScope::perform_action(VariantMap const& result,
@@ -168,7 +167,7 @@
                                          proxy.getEndpoint().cStr(),
                                          proxy.getIdentity().cStr(),
                                          proxy.getCategory().cStr()));
-    return make_shared<QueryCtrlImpl>(p, reply_proxy, mw_base()->runtime()->logger());
+    return make_shared<QueryCtrlImpl>(p, reply_proxy);
 }
 
 QueryCtrlProxy ZmqScope::preview(VariantMap const& result, VariantMap const& hints, MWReplyProxy const& reply)
@@ -198,7 +197,7 @@
                                          proxy.getEndpoint().cStr(),
                                          proxy.getIdentity().cStr(),
                                          proxy.getCategory().cStr()));
-    return make_shared<QueryCtrlImpl>(p, reply_proxy, mw_base()->runtime()->logger());
+    return make_shared<QueryCtrlImpl>(p, reply_proxy);
 }
 
 bool ZmqScope::debug_mode()

=== modified file 'src/scopes/testing/InProcessBenchmark.cpp'
--- src/scopes/testing/InProcessBenchmark.cpp	2014-08-28 00:20:56 +0000
+++ src/scopes/testing/InProcessBenchmark.cpp	2015-01-13 07:11:02 +0000
@@ -208,6 +208,10 @@
     {
         return true;
     }
+
+    void push_surfacing_results_from_cache() override
+    {
+    }
 };
 
 typedef std::chrono::high_resolution_clock Clock;

=== modified file 'src/scopes/utility/internal/BufferedResultForwarderImpl.cpp'
--- src/scopes/utility/internal/BufferedResultForwarderImpl.cpp	2014-12-01 09:47:04 +0000
+++ src/scopes/utility/internal/BufferedResultForwarderImpl.cpp	2015-01-13 07:11:02 +0000
@@ -72,7 +72,7 @@
     // scope author tells us that results for this forwarder are now ready
     // to be displayed (or the query has finished); set the 'ready' flag
     // and if previous forwarder is also ready, then push and disable
-    // futher buffering.
+    // further buffering.
     if (!ready_.exchange(true))
     {
         if (previous_ready_ || !has_previous_)

=== modified file 'src/scopes/utility/internal/BufferedSearchReplyImpl.cpp'
--- src/scopes/utility/internal/BufferedSearchReplyImpl.cpp	2014-12-01 01:51:38 +0000
+++ src/scopes/utility/internal/BufferedSearchReplyImpl.cpp	2015-01-13 07:11:02 +0000
@@ -92,6 +92,11 @@
     return upstream_->push(filters, filter_state);
 }
 
+void BufferedSearchReplyImpl::push_surfacing_results_from_cache()
+{
+    upstream_->push_surfacing_results_from_cache();
+}
+
 void BufferedSearchReplyImpl::finished()
 {
     upstream_->finished();

=== modified file 'test/gtest/scopes/Activation/Activation_test.cpp'
--- test/gtest/scopes/Activation/Activation_test.cpp	2014-12-04 04:33:50 +0000
+++ test/gtest/scopes/Activation/Activation_test.cpp	2015-01-13 07:11:02 +0000
@@ -554,7 +554,7 @@
     auto mw = rt->factory()->create("TestScope", "Zmq", TEST_DIR "/Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     VariantMap hints;
     auto receiver = std::make_shared<SearchReceiver>();

=== modified file 'test/gtest/scopes/Activation/Runtime.ini.in'
--- test/gtest/scopes/Activation/Runtime.ini.in	2014-09-05 04:00:28 +0000
+++ test/gtest/scopes/Activation/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+LogDir=

=== modified file 'test/gtest/scopes/CMakeLists.txt'
--- test/gtest/scopes/CMakeLists.txt	2014-12-01 01:51:38 +0000
+++ test/gtest/scopes/CMakeLists.txt	2015-01-13 07:11:02 +0000
@@ -25,6 +25,7 @@
 add_subdirectory(RangeInputFilter)
 add_subdirectory(RatingFilter)
 add_subdirectory(ReplyReaper)
+add_subdirectory(ResultCache)
 add_subdirectory(SwitchFilter)
 add_subdirectory(ValueSliderFilter)
 add_subdirectory(PreviewWidget)

=== modified file 'test/gtest/scopes/Filters/Filters_test.cpp'
--- test/gtest/scopes/Filters/Filters_test.cpp	2014-12-04 04:33:50 +0000
+++ test/gtest/scopes/Filters/Filters_test.cpp	2015-01-13 07:11:02 +0000
@@ -124,7 +124,7 @@
     auto mw = rt->factory()->create("TestScope", "Zmq", TEST_DIR "/Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     SearchMetadata hints("pl", "phone");
     auto receiver = std::make_shared<SearchReceiver>();

=== modified file 'test/gtest/scopes/Filters/Runtime.ini.in'
--- test/gtest/scopes/Filters/Runtime.ini.in	2014-09-05 04:00:28 +0000
+++ test/gtest/scopes/Filters/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+LogDir=

=== modified file 'test/gtest/scopes/IdleShutdown/IdleShutdown_test.cpp'
--- test/gtest/scopes/IdleShutdown/IdleShutdown_test.cpp	2014-12-05 08:21:06 +0000
+++ test/gtest/scopes/IdleShutdown/IdleShutdown_test.cpp	2015-01-13 07:11:02 +0000
@@ -129,7 +129,7 @@
         auto mw = rt->factory()->create("client_middleware", "Zmq", "Zmq.ini");
         mw->start();
         auto proxy = mw->create_scope_proxy("SlowSearchScope");
-        auto scope = internal::ScopeImpl::create(proxy, rt.get(), "SlowSearchScope");
+        auto scope = internal::ScopeImpl::create(proxy, "SlowSearchScope");
 
         // Create a query, which takes 4 seconds to complete in the scope.
         auto receiver = make_shared<NullReceiver>();

=== modified file 'test/gtest/scopes/IdleShutdown/Runtime.ini.in'
--- test/gtest/scopes/IdleShutdown/Runtime.ini.in	2014-07-18 06:41:02 +0000
+++ test/gtest/scopes/IdleShutdown/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = Zmq.ini
+LogDir=

=== modified file 'test/gtest/scopes/Invocation/Invocation_test.cpp'
--- test/gtest/scopes/Invocation/Invocation_test.cpp	2014-12-04 04:33:50 +0000
+++ test/gtest/scopes/Invocation/Invocation_test.cpp	2015-01-13 07:11:02 +0000
@@ -118,7 +118,7 @@
     auto mw = rt->factory()->create("TestScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     auto receiver = make_shared<TestReceiver>();
 
@@ -150,7 +150,7 @@
     auto mw = rt->factory()->create("DebugTestScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("DebugTestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     auto receiver = make_shared<TestReceiver>();
 
@@ -186,7 +186,7 @@
     auto mw = rt->factory()->create("EmptyScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("EmptyScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "EmptyScope");
+    auto scope = internal::ScopeImpl::create(proxy, "EmptyScope");
 
     auto receiver = make_shared<NullReceiver>();
 

=== modified file 'test/gtest/scopes/Invocation/Runtime.ini.in'
--- test/gtest/scopes/Invocation/Runtime.ini.in	2014-07-18 07:09:57 +0000
+++ test/gtest/scopes/Invocation/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = Zmq.ini
+LogDir=

=== modified file 'test/gtest/scopes/Registry/Runtime.ini.in'
--- test/gtest/scopes/Registry/Runtime.ini.in	2014-05-08 06:04:29 +0000
+++ test/gtest/scopes/Registry/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -4,3 +4,4 @@
 Default.Middleware = Zmq
 Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
 Smartscopes.Registry.Identity =
+LogDir=

=== modified file 'test/gtest/scopes/ReplyReaper/ReplyReaper_test.cpp'
--- test/gtest/scopes/ReplyReaper/ReplyReaper_test.cpp	2014-12-04 04:33:50 +0000
+++ test/gtest/scopes/ReplyReaper/ReplyReaper_test.cpp	2015-01-13 07:11:02 +0000
@@ -99,7 +99,7 @@
         auto mw = rt->factory()->create("NoReplyScope", "Zmq", TEST_DIR "/Zmq.ini");
         mw->start();
         auto proxy = mw->create_scope_proxy("NoReplyScope");
-        auto scope = internal::ScopeImpl::create(proxy, rt.get(), "NoReplyScope");
+        auto scope = internal::ScopeImpl::create(proxy, "NoReplyScope");
 
         auto receiver = make_shared<NullReceiver>();
         scope->search("test", SearchMetadata("en", "phone"), receiver);
@@ -171,7 +171,7 @@
         auto mw = rt->factory()->create("NoReplyScope", "Zmq", TEST_DIR "/Zmq.ini");
         mw->start();
         auto proxy = mw->create_scope_proxy("NoReplyScope");
-        auto scope = internal::ScopeImpl::create(proxy, rt.get(), "NoReplyScope");
+        auto scope = internal::ScopeImpl::create(proxy, "NoReplyScope");
 
         auto receiver = make_shared<NoReapReceiver>();
         scope->search("test", SearchMetadata("en", "phone"), receiver);

=== modified file 'test/gtest/scopes/ReplyReaper/Runtime.ini.in'
--- test/gtest/scopes/ReplyReaper/Runtime.ini.in	2014-07-29 06:16:45 +0000
+++ test/gtest/scopes/ReplyReaper/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -5,3 +5,4 @@
 Reap.Interval = 1
 Default.Middleware = Zmq
 Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+LogDir=

=== added directory 'test/gtest/scopes/ResultCache'
=== added file 'test/gtest/scopes/ResultCache/CMakeLists.txt'
--- test/gtest/scopes/ResultCache/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CMakeLists.txt	2015-01-13 07:11:02 +0000
@@ -0,0 +1,27 @@
+configure_file(TestRegistry.ini.in ${CMAKE_CURRENT_BINARY_DIR}/TestRegistry.ini)
+configure_file(Runtime.ini.in ${CMAKE_CURRENT_BINARY_DIR}/Runtime.ini)
+configure_file(Zmq.ini.in ${CMAKE_CURRENT_BINARY_DIR}/Zmq.ini)
+
+add_definitions(-DTEST_SOURCE_PATH="${CMAKE_CURRENT_SOURCE_DIR}")
+add_definitions(-DTEST_RUNTIME_PATH="${CMAKE_CURRENT_BINARY_DIR}")
+add_definitions(-DTEST_RUNTIME_FILE="${CMAKE_CURRENT_BINARY_DIR}/Runtime.ini")
+add_definitions(-DTEST_REGISTRY_PATH="${PROJECT_BINARY_DIR}/scoperegistry")
+
+add_executable(ResultCache_test ResultCache_test.cpp CacheScope.cpp)
+target_link_libraries(ResultCache_test ${TESTLIBS})
+
+add_dependencies(ResultCache_test scoperegistry scoperunner)
+
+add_test(ResultCache ResultCache_test)
+
+set(SCOPE_DIR "${CMAKE_CURRENT_BINARY_DIR}/scopes")
+
+foreach (scope CacheScope AlwaysPushFromCacheScope)
+    file(MAKE_DIRECTORY "${SCOPE_DIR}/${scope}")
+    configure_file(CacheScope.ini.in ${SCOPE_DIR}/${scope}/${scope}.ini)
+    add_library(${scope} MODULE CacheScope.cpp)
+    set_target_properties(${scope}
+      PROPERTIES
+        LIBRARY_OUTPUT_DIRECTORY "${SCOPE_DIR}/${scope}/"
+    )
+endforeach()

=== added file 'test/gtest/scopes/ResultCache/CacheScope.cpp'
--- test/gtest/scopes/ResultCache/CacheScope.cpp	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.cpp	2015-01-13 07:11:02 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include "CacheScope.h"
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/ScopeBase.h>
+#include <unity/scopes/ScopeExceptions.h>
+#include <unity/scopes/SearchReply.h>
+
+#include <boost/filesystem.hpp>
+#include <unity/UnityExceptions.h>
+#include <unity/util/FileIO.h>
+
+#include <atomic>
+#include <mutex>
+
+using namespace std;
+using namespace unity::scopes;
+
+namespace
+{
+
+class TestQuery : public SearchQueryBase
+{
+public:
+    TestQuery(CannedQuery const& query,
+              SearchMetadata const& metadata,
+              string const& id,
+              RegistryProxy const& reg)
+        : SearchQueryBase(query, metadata)
+        , id_(id)
+        , registry_(reg)
+    {
+    }
+
+    virtual void cancelled() override
+    {
+    }
+
+    virtual void run(SearchReplyProxy const& reply) override
+    {
+        if (id_ == "AlwaysPushFromCacheScope")
+        {
+            // So we get coverage on pushing from cache before a cache file exists.
+            reply->push_surfacing_results_from_cache();
+            return;
+        }
+
+        if (query().query_string().empty())
+        {
+            // If there is a cache file, we use it to push.
+            boost::system::error_code ec;
+            if (boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec))
+            {
+                reply->push_surfacing_results_from_cache();
+                // We do this twice, to get coverage on the double-call guard.
+                reply->push_surfacing_results_from_cache();
+                return;
+            }
+        }
+        else if (query().query_string() == "non-empty from cache")
+        {
+            // This gives us coverage for the case that we are pushing from the cache for a non-empty query.
+            reply->push_surfacing_results_from_cache();
+            return;
+        }
+
+        auto depts = Department::create("", query(), "Top");
+        auto sub_dept = Department::create("sub" + query().query_string(), query(), "Sub");
+        depts->add_subdepartment(move(sub_dept));
+        reply->register_departments(move(depts));
+        auto cat = reply->register_category(id_, "", "");
+        CategorisedResult res(cat);
+        res.set_uri("uri");
+        res.set_title(query().query_string());
+        if (valid())
+        {
+            reply->push(res);
+        }
+    }
+
+private:
+    string id_;
+    RegistryProxy registry_;
+};
+
+}  // namespace
+
+void CacheScope::start(string const& scope_id)
+{
+    lock_guard<mutex> lock(mutex_);
+    id_ = scope_id;
+}
+
+void CacheScope::stop()
+{
+}
+
+void CacheScope::run()
+{
+}
+
+SearchQueryBase::UPtr CacheScope::search(CannedQuery const& query, SearchMetadata const& metadata)
+{
+    lock_guard<mutex> lock(mutex_);
+    return SearchQueryBase::UPtr(new TestQuery(query, metadata, id_, registry()));
+}
+
+PreviewQueryBase::UPtr CacheScope::preview(Result const&, ActionMetadata const &)
+{
+    return nullptr;  // unused
+}
+
+extern "C"
+{
+
+    unity::scopes::ScopeBase*
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_CREATE_FUNCTION()
+    {
+        return new CacheScope;
+    }
+
+    void
+    // cppcheck-suppress unusedFunction
+    UNITY_SCOPE_DESTROY_FUNCTION(unity::scopes::ScopeBase* scope_base)
+    {
+        delete scope_base;
+    }
+}

=== added file 'test/gtest/scopes/ResultCache/CacheScope.h'
--- test/gtest/scopes/ResultCache/CacheScope.h	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.h	2015-01-13 07:11:02 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#pragma once
+
+#include <unity/scopes/ScopeBase.h>
+
+class CacheScope : public unity::scopes::ScopeBase
+{
+public:
+    virtual void start(std::string const&) override;
+
+    virtual void stop() override;
+
+    virtual void run() override;
+
+    virtual unity::scopes::SearchQueryBase::UPtr search(unity::scopes::CannedQuery const &,
+                                                        unity::scopes::SearchMetadata const &) override;
+
+    virtual unity::scopes::PreviewQueryBase::UPtr preview(unity::scopes::Result const&,
+                                                          unity::scopes::ActionMetadata const &) override;
+
+private:
+    std::string id_;
+    std::mutex mutex_;
+};

=== added file 'test/gtest/scopes/ResultCache/CacheScope.ini.in'
--- test/gtest/scopes/ResultCache/CacheScope.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/CacheScope.ini.in	2015-01-13 07:11:02 +0000
@@ -0,0 +1,4 @@
+[ScopeConfig]
+DisplayName = CacheScope
+Description = Scope that pushes cached results for surfacing query
+Author = Michi

=== added file 'test/gtest/scopes/ResultCache/ResultCache_test.cpp'
--- test/gtest/scopes/ResultCache/ResultCache_test.cpp	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/ResultCache_test.cpp	2015-01-13 07:11:02 +0000
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michi Henning <[e-mail]>
+ */
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/internal/RegistryObject.h>
+#include <unity/scopes/internal/RuntimeImpl.h>
+#include <unity/scopes/internal/ScopeImpl.h>
+
+#include <boost/filesystem.hpp>
+#include <gtest/gtest.h>
+
+#include "CacheScope.h"
+
+using namespace std;
+using namespace unity::scopes;
+using namespace unity::scopes::internal;
+
+class Receiver : public SearchListenerBase
+{
+public:
+    Receiver()
+        : query_complete_(false)
+    {
+    }
+
+    virtual void push(Department::SCPtr const& parent) override
+    {
+        lock_guard<mutex> lock(mutex_);
+        dept_ = parent;
+    }
+
+    virtual void push(CategorisedResult result) override
+    {
+        lock_guard<mutex> lock(mutex_);
+        result_ = make_shared<CategorisedResult>(result);
+    }
+
+    virtual void finished(CompletionDetails const& details) override
+    {
+        EXPECT_EQ(CompletionDetails::OK, details.status()) << details.message();
+        lock_guard<mutex> lock(mutex_);
+        query_complete_ = true;
+        cond_.notify_one();
+    }
+
+    void wait_until_finished()
+    {
+        unique_lock<mutex> lock(mutex_);
+        cond_.wait(lock, [this] { return this->query_complete_; });
+        query_complete_ = false;
+    }
+
+    Department::SCPtr dept() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return dept_;
+    }
+
+    CategorisedResult::SCPtr result() const
+    {
+        lock_guard<mutex> lock(mutex_);
+        return result_;
+    }
+
+private:
+    Department::SCPtr dept_;
+    CategorisedResult::SCPtr result_;
+    bool query_complete_;
+    mutable mutex mutex_;
+    condition_variable cond_;
+};
+
+class CacheScopeTest : public ::testing::Test
+{
+public:
+    CacheScopeTest()
+    {
+        runtime_ = Runtime::create(TEST_RUNTIME_FILE);
+        auto reg = runtime_->registry();
+        auto meta = reg->get_metadata("CacheScope");
+        scope_ = meta.proxy();
+        meta = reg->get_metadata("AlwaysPushFromCacheScope");
+        always_push_from_cache_scope_ = meta.proxy();
+    }
+
+    ScopeProxy scope() const
+    {
+        return scope_;
+    }
+
+    ScopeProxy always_push_from_cache_scope() const
+    {
+        return always_push_from_cache_scope_;
+    }
+
+private:
+    Runtime::UPtr runtime_;
+    ScopeProxy scope_;
+    ScopeProxy always_push_from_cache_scope_;
+};
+
+TEST_F(CacheScopeTest, push_from_cache_without_cache_file)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/AlwaysPushFromCacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    always_push_from_cache_scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r, nullptr);
+}
+
+TEST_F(CacheScopeTest, non_surfacing_query)
+{
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0700);
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("some query", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "some query");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "subsome query");
+
+    // Non-empty query, so there must be no cache file.
+    boost::system::error_code ec;
+    EXPECT_FALSE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, surfacing_query)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+
+    // Empty query, so there must be a cache file.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+// Run another non-surfacing query before checking that the cache contains the
+// results of the last surfacing query.
+
+TEST_F(CacheScopeTest, non_surfacing_query2)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("some other query", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "some other query");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "subsome other query");
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, push_from_cache)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, push_non_empty_from_cache)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("non-empty from cache", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    // Cache file must still be there.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, write_failure)
+{
+    ::unlink(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0);
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    // Empty query, but cache file could not be created
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope", 0700);
+    boost::system::error_code ec;
+    EXPECT_FALSE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, surfacing_query_2)
+{
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+
+    auto r = receiver->result();
+    EXPECT_EQ(r->title(), "");
+    auto d = receiver->dept();
+    EXPECT_EQ(d->id(), "");
+    auto sd = *d->subdepartments().begin();
+    EXPECT_EQ(sd->id(), "sub");
+
+    // New cache file must have been created
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, read_failure)
+{
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", 0);
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+    ::chmod(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", 0600);
+
+    // Cache file must still be there, but read will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+// Stop warnings about unused return value from system()
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+
+TEST_F(CacheScopeTest, missing_departments)
+{
+    // Get coverage on missing departments entry
+    system("cp " TEST_SOURCE_PATH "/no_dept_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_categories)
+{
+    // Get coverage on missing categories entry
+    system("cp " TEST_SOURCE_PATH "/no_cat_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+TEST_F(CacheScopeTest, missing_results)
+{
+    // Get coverage on missing results entry
+    system("cp " TEST_SOURCE_PATH "/no_results_cache " TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache");
+    auto receiver = make_shared<Receiver>();
+    scope()->search("", SearchMetadata("unused", "unused"), receiver);
+    receiver->wait_until_finished();
+    EXPECT_EQ(receiver->result(), nullptr);
+
+    // Cache file must still be there, but decode will have failed.
+    boost::system::error_code ec;
+    EXPECT_TRUE(boost::filesystem::exists(TEST_RUNTIME_PATH "/unconfined/CacheScope/.surfacing_cache", ec));
+}
+
+#pragma GCC diagnostic pop
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+
+    int rc = 0;
+
+    // Set the "TEST_DESKTOP_FILES_DIR" env var before forking as not to create desktop files in ~/.local
+    putenv(const_cast<char*>("TEST_DESKTOP_FILES_DIR=" TEST_RUNTIME_PATH));
+
+    auto rpid = fork();
+    if (rpid == 0)
+    {
+        const char* const args[] = {"scoperegistry [CacheScope_test]", TEST_RUNTIME_FILE, nullptr};
+        if (execv(TEST_REGISTRY_PATH "/scoperegistry", const_cast<char* const*>(args)) < 0)
+        {
+            perror("Error starting scoperegistry:");
+        }
+        return 1;
+    }
+    else if (rpid > 0)
+    {
+        rc = RUN_ALL_TESTS();
+        kill(rpid, SIGTERM);
+        waitpid(rpid, nullptr, 0);
+    }
+    else
+    {
+        perror("Failed to fork:");
+    }
+
+    return rc;
+}

=== added file 'test/gtest/scopes/ResultCache/Runtime.ini.in'
--- test/gtest/scopes/ResultCache/Runtime.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -0,0 +1,8 @@
+[Runtime]
+Registry.Identity = TestRegistry
+Registry.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/TestRegistry.ini
+Default.Middleware = Zmq
+Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+Smartscopes.Registry.Identity =
+CacheDir=@CMAKE_CURRENT_BINARY_DIR@
+LogDir=

=== added file 'test/gtest/scopes/ResultCache/TestRegistry.ini.in'
--- test/gtest/scopes/ResultCache/TestRegistry.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/TestRegistry.ini.in	2015-01-13 07:11:02 +0000
@@ -0,0 +1,7 @@
+[Registry]
+Middleware = Zmq
+Zmq.ConfigFile = @CMAKE_CURRENT_BINARY_DIR@/Zmq.ini
+Scope.InstallDir = @CMAKE_CURRENT_BINARY_DIR@/scopes
+OEM.InstallDir = /unused
+Click.InstallDir = @CMAKE_CURRENT_BINARY_DIR@/click
+Scoperunner.Path = @PROJECT_BINARY_DIR@/scoperunner/scoperunner

=== added file 'test/gtest/scopes/ResultCache/Zmq.ini.in'
--- test/gtest/scopes/ResultCache/Zmq.ini.in	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/Zmq.ini.in	2015-01-13 07:11:02 +0000
@@ -0,0 +1,2 @@
+[Zmq]
+EndpointDir = /tmp

=== added file 'test/gtest/scopes/ResultCache/no_cat_cache'
--- test/gtest/scopes/ResultCache/no_cat_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_cat_cache	2015-01-13 07:11:02 +0000
@@ -0,0 +1,1 @@
+{"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}},"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_dept_cache'
--- test/gtest/scopes/ResultCache/no_dept_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_dept_cache	2015-01-13 07:11:02 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"results":[{"attrs":{"title":"","uri":"uri"},"internal":{"cat_id":"CacheScope"}}]}

=== added file 'test/gtest/scopes/ResultCache/no_results_cache'
--- test/gtest/scopes/ResultCache/no_results_cache	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/ResultCache/no_results_cache	2015-01-13 07:11:02 +0000
@@ -0,0 +1,1 @@
+{"categories":[{"icon":"","id":"CacheScope","renderer_template":"\n    {\n        \"schema-version\":1,\n        \"template\":\n        {\n            \"category-layout\":\"grid\"\n        },\n        \"components\":\n        {\n            \"title\":\"title\",\n            \"art\":\"art\"\n        }\n    }\n    ","title":""}],"departments":{"departments":[{"label":"Sub","query":{"department_id":"sub","filter_state":{},"query_string":"","scope":"CacheScope"}}],"label":"Top","query":{"department_id":"","filter_state":{},"query_string":"","scope":"CacheScope"}}}

=== added directory 'test/gtest/scopes/ResultCache/unconfined'
=== added directory 'test/gtest/scopes/ResultCache/unconfined/CacheScope'
=== modified file 'test/gtest/scopes/Runtime/Runtime.ini.in'
--- test/gtest/scopes/Runtime/Runtime.ini.in	2014-07-18 07:30:20 +0000
+++ test/gtest/scopes/Runtime/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = Zmq.ini
+LogDir=

=== modified file 'test/gtest/scopes/Runtime/Runtime_test.cpp'
--- test/gtest/scopes/Runtime/Runtime_test.cpp	2014-12-05 02:39:39 +0000
+++ test/gtest/scopes/Runtime/Runtime_test.cpp	2015-01-13 07:11:02 +0000
@@ -309,7 +309,7 @@
     auto mw = rt->factory()->create("TestScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     auto receiver = make_shared<Receiver>();
     auto ctrl = scope->search("test", SearchMetadata("en", "phone"), receiver);
@@ -324,7 +324,7 @@
     mw->start();
 
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     auto receiver = make_shared<Receiver>();
     auto ctrl = scope->search("test", SearchMetadata("en", "phone"), receiver);
@@ -367,7 +367,7 @@
     auto mw = rt->factory()->create("TestScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("TestScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "TestScope");
+    auto scope = internal::ScopeImpl::create(proxy, "TestScope");
 
     // run a query first, so we have a result to preview
     auto receiver = make_shared<Receiver>();
@@ -396,7 +396,7 @@
     auto mw = rt->factory()->create("PusherScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("PusherScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "PusherScope");
+    auto scope = internal::ScopeImpl::create(proxy, "PusherScope");
 
     // Run a query with unlimited cardinality. We check that the
     // scope returns 100 results.
@@ -453,7 +453,7 @@
     auto mw = rt->factory()->create("SlowCreateScope", "Zmq", "Zmq.ini");
     mw->start();
     auto proxy = mw->create_scope_proxy("SlowCreateScope");
-    auto scope = internal::ScopeImpl::create(proxy, rt.get(), "SlowCreateScope");
+    auto scope = internal::ScopeImpl::create(proxy, "SlowCreateScope");
 
     // Allow some time for the middleware to start up.
     this_thread::sleep_for(chrono::milliseconds(200));

=== modified file 'test/gtest/scopes/internal/ResultReplyObject/Runtime.ini.in'
--- test/gtest/scopes/internal/ResultReplyObject/Runtime.ini.in	2014-02-24 14:56:26 +0000
+++ test/gtest/scopes/internal/ResultReplyObject/Runtime.ini.in	2015-01-13 07:11:02 +0000
@@ -3,3 +3,4 @@
 Registry.ConfigFile = Registry.ini
 Default.Middleware = Zmq
 Zmq.ConfigFile = Zmq.ini
+LogDir=

=== added file 'test/gtest/scopes/internal/RuntimeConfig/BadLogDirSize.ini'
--- test/gtest/scopes/internal/RuntimeConfig/BadLogDirSize.ini	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/internal/RuntimeConfig/BadLogDirSize.ini	2015-01-13 07:11:02 +0000
@@ -0,0 +1,7 @@
+[Runtime]
+CacheDir = cachedir
+AppDir = appdir
+ConfigDir = configdir
+LogDir = logdir
+Log.MaxFileSize = 2048
+Log.MaxDirSize = 1024

=== added file 'test/gtest/scopes/internal/RuntimeConfig/BadLogFileSize.ini'
--- test/gtest/scopes/internal/RuntimeConfig/BadLogFileSize.ini	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/internal/RuntimeConfig/BadLogFileSize.ini	2015-01-13 07:11:02 +0000