Merge lp:~mandel/ubuntu-download-manager/client-logging into lp:ubuntu-download-manager

[Manuel de la Peña]

Add a loger class that can be used by the clients to set the logging type.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:323
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/684/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/43
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/43
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/43/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/684/rebuild

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/client-logging]

324. By Manuel de la Peña on 2014-06-30

Hide priv documentation.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:324
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/685/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/44
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/44
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/44/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/685/rebuild

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/client-logging]

325. By Manuel de la Peña on 2014-07-02

Initialize pointer to null.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:325
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/689/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/48
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/48
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/48/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/689/rebuild

review: Approve (continuous-integration)

[lp:~mandel/ubuntu-download-manager/client-logging]

326. By Manuel de la Peña on 2014-07-02

Fix cmake and remove the need to linking against glog for the client library.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:326
http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-ci/692/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-amd64-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-download-manager-utopic-armhf-ci/51/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-download-manager-ci/692/rebuild

review: Approve (continuous-integration)

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Michael Sheldon (michael-sheldon)]

Looks good to me, only had one note on the naming of a couple of functions (see diff comments), but that's as much a matter of personal preference as anything.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-07-03 10:39:05 +0000
+++ CMakeLists.txt	2014-07-03 10:39:06 +0000
@@ -31,7 +31,7 @@
 )
 
 set(UDM_VERSION_MAJOR 0)
-set(UDM_VERSION_MINOR 5)
+set(UDM_VERSION_MINOR 6)
 set(UDM_VERSION_PATCH 0)
 
 find_package(Gtest REQUIRED)
@@ -46,6 +46,7 @@
 find_package(Qt5SystemInfo REQUIRED)
 find_package(Qt5Sql REQUIRED)
 find_package(Qt5Test REQUIRED)
+find_package(Boost COMPONENTS log REQUIRED)
 
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(DBUS REQUIRED dbus-1)

=== modified file 'debian/changelog'
--- debian/changelog	2014-07-03 10:39:05 +0000
+++ debian/changelog	2014-07-03 10:39:06 +0000
@@ -1,3 +1,11 @@
+ubuntu-download-manager (0.6) UNRELEASED; urgency=medium
+
+  * Add a new public object in the client library that provides a way
+    to configure the logging done in the client library. ABI is changed
+    and a new dependency is added.
+
+ -- Manuel de la Pena <[e-mail]>  Thu, 26 Jun 2014 13:00:45 +0200
+
 ubuntu-download-manager (0.5) UNRELEASED; urgency=medium
 
   * Add support to set the headers for a single file download. This change

=== modified file 'debian/control'
--- debian/control	2014-04-30 14:59:42 +0000
+++ debian/control	2014-07-03 10:39:06 +0000
@@ -10,6 +10,7 @@
                qt5-default,
                qtbase5-dev,
                qtsystems5-dev,
+               libboost-log-dev,
                libdbus-1-dev,
                libqt5sql5-sqlite,
                libnih-dbus-dev,

=== modified file 'debian/libubuntu-download-manager-client0.symbols'
--- debian/libubuntu-download-manager-client0.symbols	2014-06-18 14:49:04 +0000
+++ debian/libubuntu-download-manager-client0.symbols	2014-07-03 10:39:06 +0000
@@ -24,6 +24,7 @@
  (c++)"Ubuntu::DownloadManager::ProcessError::~ProcessError()@Base" 0.4+14.10.20140618
  (c++)"Ubuntu::DownloadManager::ProcessError::~ProcessError()@Base" 0.4+14.10.20140618
  (c++)"Ubuntu::DownloadManager::ProcessError::~ProcessError()@Base" 0.4+14.10.20140618
+ (c++)"Ubuntu::DownloadManager::Logging::Logger::init(Ubuntu::DownloadManager::Logging::Logger::Level, QString const&)@Base" 0replaceme 
  (c++)"Ubuntu::DownloadManager::DownloadsList::qt_metacall(QMetaObject::Call, int, void**)@Base" 0.4+14.10.20140618
  (c++)"Ubuntu::DownloadManager::DownloadsList::qt_metacast(char const*)@Base" 0.4+14.10.20140618
  (c++)"Ubuntu::DownloadManager::DownloadsList::staticMetaObject@Base" 0.4+14.10.20140618

=== modified file 'src/common/public/ubuntu/transfers/system/logger.cpp'
--- src/common/public/ubuntu/transfers/system/logger.cpp	2014-03-28 15:50:24 +0000
+++ src/common/public/ubuntu/transfers/system/logger.cpp	2014-07-03 10:39:06 +0000
@@ -118,6 +118,7 @@
         google::SetLogDestination(google::ERROR, toStdString(path).c_str());
         google::SetLogDestination(google::WARNING, toStdString(path).c_str());
         google::SetLogDestination(google::INFO, toStdString(path).c_str());
+        google::SetLogDestination(google::FATAL, toStdString(path).c_str());
     }
 }
 

=== modified file 'src/downloads/client/CMakeLists.txt'
--- src/downloads/client/CMakeLists.txt	2014-06-17 10:23:15 +0000
+++ src/downloads/client/CMakeLists.txt	2014-07-03 10:39:06 +0000
@@ -1,9 +1,11 @@
+add_definitions(-DBOOST_LOG_DYN_LINK)
+
 set(TARGET ubuntu-download-manager-client)
 
 set(SOURCES
         ubuntu/download_manager/download_impl.cpp
         ubuntu/download_manager/download_interface.cpp
-	ubuntu/download_manager/downloads_list_impl.cpp
+        ubuntu/download_manager/downloads_list_impl.cpp
         ubuntu/download_manager/download_pendingcall_watcher.cpp
         ubuntu/download_manager/error.cpp
         ubuntu/download_manager/group_download.cpp
@@ -11,21 +13,23 @@
         ubuntu/download_manager/manager_impl.cpp
         ubuntu/download_manager/manager_interface.cpp
         ubuntu/download_manager/manager_pendingcall_watcher.cpp
+        ubuntu/download_manager/logging/logger.cpp
         ubuntu/download_manager/pending_call_watcher.cpp
 )
 
 set(PUBLIC_HEADERS
         ubuntu/download_manager/download.h
-	ubuntu/download_manager/downloads_list.h
+        ubuntu/download_manager/downloads_list.h
         ubuntu/download_manager/error.h
         ubuntu/download_manager/group_download.h
         ubuntu/download_manager/manager.h
+        ubuntu/download_manager/logging/logger.h
 )
 
 set(PRIVATE_HEADERS
         ubuntu/download_manager/download_impl.h
         ubuntu/download_manager/download_interface.h
-	ubuntu/download_manager/downloads_list_impl.h
+        ubuntu/download_manager/downloads_list_impl.h
         ubuntu/download_manager/download_pendingcall_watcher.h
         ubuntu/download_manager/manager_impl.h
         ubuntu/download_manager/manager_interface.h
@@ -37,30 +41,31 @@
 include_directories(${Qt5Network_INCLUDE_DIRS})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
+include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${CMAKE_SOURCE_DIR}/src/common/public)
 include_directories(${CMAKE_SOURCE_DIR}/src/downloads/common)
 
 add_library(${TARGET} SHARED 
-	${SOURCES}
-	${PUBLIC_HEADERS}
-	${PRIVATE_HEADERS}
+        ${SOURCES}
+        ${PUBLIC_HEADERS}
+        ${PRIVATE_HEADERS}
 )
 
 set(symbol_map "${CMAKE_SOURCE_DIR}/src/downloads/client/symbols.map")
 set_target_properties(
-	${TARGET}
+        ${TARGET}
 
-	PROPERTIES
+        PROPERTIES
         LINK_FLAGS "${ldflags} -Wl,--version-script,${symbol_map}"
         LINK_DEPENDS ${symbol_map}
-	VERSION ${UDM_VERSION_MAJOR}.${UDM_VERSION_MINOR}.${UDM_VERSION_PATCH}
-	SOVERSION ${UDM_VERSION_MAJOR}
+        VERSION ${UDM_VERSION_MAJOR}.${UDM_VERSION_MINOR}.${UDM_VERSION_PATCH}
+        SOVERSION ${UDM_VERSION_MAJOR}
 )
 
 target_link_libraries(${TARGET}
-	${Qt5DBus_LIBRARIES}
-	${GLOG_LIBRARIES}
-	udm-common
+        ${Boost_LIBRARIES}
+        ${Qt5DBus_LIBRARIES}
+        udm-common
         ubuntu-download-manager-common
 )
 

=== modified file 'src/downloads/client/symbols.map'
--- src/downloads/client/symbols.map	2014-06-17 10:23:15 +0000
+++ src/downloads/client/symbols.map	2014-07-03 10:39:06 +0000
@@ -11,6 +11,7 @@
         Ubuntu::DownloadManager::ProcessError::*;
         Ubuntu::DownloadManager::GroupDownload::*;
         Ubuntu::DownloadManager::Manager::*;
+        Ubuntu::DownloadManager::Logging::Logger::init*;
         typeinfo?for?Ubuntu::DownloadManager::Download;
         typeinfo?for?Ubuntu::DownloadManager::DownloadsList;
         typeinfo?for?Ubuntu::DownloadManager::Error;
@@ -21,6 +22,7 @@
         typeinfo?for?Ubuntu::DownloadManager::ProcessError;
         typeinfo?for?Ubuntu::DownloadManager::GroupDownload;
         typeinfo?for?Ubuntu::DownloadManager::Manager;
+        typeinfo?for?Ubuntu::DownloadManager::Logging::Logger;
         typeinfo?name?for?Ubuntu::DownloadManager::Download;
         typeinfo?name?for?Ubuntu::DownloadManager::DownloadsList;
         typeinfo?name?for?Ubuntu::DownloadManager::Error;
@@ -31,6 +33,7 @@
         typeinfo?name?for?Ubuntu::DownloadManager::ProcessError;
         typeinfo?name?for?Ubuntu::DownloadManager::GroupDownload;
         typeinfo?name?for?Ubuntu::DownloadManager::Manager;
+        typeinfo?name?for?Ubuntu::DownloadManager::Logging::Logger;
         VTT?for?Ubuntu::DownloadManager::Download;
         VTT?for?Ubuntu::DownloadManager::DownloadsList;
         VTT?for?Ubuntu::DownloadManager::Error;
@@ -41,6 +44,7 @@
         VTT?for?Ubuntu::DownloadManager::ProcessError;
         VTT?for?Ubuntu::DownloadManager::GroupDownload;
         VTT?for?Ubuntu::DownloadManager::Manager;
+        VTT?for?Ubuntu::DownloadManager::Logging::Logger;
         virtual?thunk?to?Ubuntu::DownloadManager::Download;
         virtual?thunk?to?Ubuntu::DownloadManager::DownloadsList;
         virtual?thunk?to?Ubuntu::DownloadManager::Error;
@@ -51,6 +55,7 @@
         virtual?thunk?to?Ubuntu::DownloadManager::ProcessError;
         virtual?thunk?to?Ubuntu::DownloadManager::GroupDownload;
         virtual?thunk?to?Ubuntu::DownloadManager::Manager;
+        virtual?thunk?to?Ubuntu::DownloadManager::Logging::Logger;
         vtable?for?Ubuntu::DownloadManager::Download;
         vtable?for?Ubuntu::DownloadManager::DownloadsList;
         vtable?for?Ubuntu::DownloadManager::Error;
@@ -61,6 +66,7 @@
         vtable?for?Ubuntu::DownloadManager::ProcessError;
         vtable?for?Ubuntu::DownloadManager::GroupDownload;
         vtable?for?Ubuntu::DownloadManager::Manager;
+        vtable?for?Ubuntu::DownloadManager::Logging::Logger;
 	std::function*
     };
 

=== modified file 'src/downloads/client/ubuntu/download_manager/download_impl.cpp'
--- src/downloads/client/ubuntu/download_manager/download_impl.cpp	2014-07-03 10:39:05 +0000
+++ src/downloads/client/ubuntu/download_manager/download_impl.cpp	2014-07-03 10:39:06 +0000
@@ -16,13 +16,15 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <glog/logging.h>
+#include <ubuntu/download_manager/logging/logger.h>
 #include "download_impl.h"
 
 namespace Ubuntu {
 
 namespace DownloadManager {
 
+using namespace Logging;
+
 DownloadImpl::DownloadImpl(const QDBusConnection& conn,
                            const QString& servicePath,
                            const QDBusObjectPath& objectPath,
@@ -31,38 +33,92 @@
       _id(objectPath.path()),
       _conn(conn),
       _servicePath(servicePath) {
+
     _dbusInterface = new DownloadInterface(servicePath,
         _id, conn);
 
     // fwd all the signals but the error one
-    CHECK(connect(_dbusInterface, &DownloadInterface::canceled,
-        this, &Download::canceled)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::finished,
-        this, &Download::finished)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::paused,
-        this, &Download::paused)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::processing,
-        this, &Download::processing)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, static_cast<void(DownloadInterface::*)
+    auto connected = connect(_dbusInterface, &DownloadInterface::canceled,
+        this, &Download::canceled);
+
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal DownloadInterface::canceled");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::finished,
+        this, &Download::finished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::finished");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::paused,
+        this, &Download::paused);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal DownloadInterface::paused");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::processing,
+        this, &Download::processing);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal DownloadInterface::processing");
+    }
+
+    connected = connect(_dbusInterface, static_cast<void(DownloadInterface::*)
         (qulonglong, qulonglong)>(&DownloadInterface::progress),
         this, static_cast<void(Download::*)
-            (qulonglong, qulonglong)>(&Download::progress)))
-            << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::resumed,
-        this, &Download::resumed)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::started,
-        this, &Download::started)) << "Could not connect to signal";
+            (qulonglong, qulonglong)>(&Download::progress));
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::progress");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::resumed,
+        this, &Download::resumed);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::resumed");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::started,
+        this, &Download::started);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::started");
+    }
 
     // connect to the different type of errors that will later be converted to
     // the error type to be used by the client.
-    CHECK(connect(_dbusInterface, &DownloadInterface::httpError,
-        this, &DownloadImpl::onHttpError)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::networkError,
-        this, &DownloadImpl::onNetworkError)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::processError,
-        this, &DownloadImpl::onProcessError)) << "Could not connect to signal";
-    CHECK(connect(_dbusInterface, &DownloadInterface::authError,
-        this, &DownloadImpl::onAuthError)) << "Could not connect to signal";
+    connected = connect(_dbusInterface, &DownloadInterface::httpError,
+        this, &DownloadImpl::onHttpError);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::httpError");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::networkError,
+        this, &DownloadImpl::onNetworkError);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::networkError");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::processError,
+        this, &DownloadImpl::onProcessError);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::processError");
+    }
+
+    connected = connect(_dbusInterface, &DownloadInterface::authError,
+        this, &DownloadImpl::onAuthError);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadInterface::authError");
+    }
 }
 
 DownloadImpl::DownloadImpl(const QDBusConnection& conn, Error* err, QObject* parent)
@@ -79,6 +135,9 @@
 
 void
 DownloadImpl::setLastError(Error* err) {
+    Logger::log(Logger::Debug,
+        QString("Download{%1} setLastError(%2)").arg(_id).arg(
+            err->errorString()));
     if (_lastError != nullptr) {
         delete _lastError;
     }
@@ -94,6 +153,7 @@
 
 void
 DownloadImpl::start() {
+    Logger::log(Logger::Debug, QString("Download{%1} start())").arg(_id));
     QDBusPendingCall call =
         _dbusInterface->start();
     auto watcher = new DownloadPCW(_conn, _servicePath,
@@ -103,6 +163,7 @@
 
 void
 DownloadImpl::pause() {
+    Logger::log(Logger::Debug, QString("Download{%1} pause())").arg(_id));
     QDBusPendingCall call =
         _dbusInterface->pause();
     auto watcher = new DownloadPCW(_conn, _servicePath,
@@ -112,6 +173,7 @@
 
 void
 DownloadImpl::resume() {
+    Logger::log(Logger::Debug, QString("Download{%1} resume())").arg(_id));
     QDBusPendingCall call =
         _dbusInterface->resume();
     auto watcher = new DownloadPCW(_conn, _servicePath,
@@ -121,6 +183,7 @@
 
 void
 DownloadImpl::cancel() {
+    Logger::log(Logger::Debug, QString("Download{%1} cancel())").arg(_id));
     QDBusPendingCall call =
         _dbusInterface->cancel();
     auto watcher = new DownloadPCW(_conn, _servicePath,
@@ -130,22 +193,28 @@
 
 void
 DownloadImpl::allowMobileDownload(bool allowed) {
+    Logger::log(Logger::Debug,
+        QString("Download{%1} allowMobileDownload%2())").arg(_id).arg(allowed));
     QDBusPendingReply<> reply =
         _dbusInterface->allowGSMDownload(allowed);
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error when setting mobile data usage");
         setLastError(reply.error());
     }
 }
 
 bool
 DownloadImpl::isMobileDownloadAllowed() {
+    Logger::log(Logger::Debug,
+        QString("Download{%1} isMobileDownloadAllowed").arg(_id));
     QDBusPendingReply<bool> reply =
         _dbusInterface->isGSMDownloadAllowed();
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error when querying mobile data usage");
         setLastError(reply.error());
         return false;
     } else {
@@ -156,33 +225,42 @@
 
 void
 DownloadImpl::setDestinationDir(const QString& path) {
+    Logger::log(Logger::Debug, QString("Dowmload{%1} setDestinationDir(%2)")
+        .arg(_id).arg(path));
     QDBusPendingReply<> reply =
         _dbusInterface->setDestinationDir(path);
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error setting the download directory");
         setLastError(reply.error());
     }
 }
 
 void
 DownloadImpl::setHeaders(QMap<QString, QString> headers) {
+    Logger::log(Logger::Debug,
+        QString("Download {%1} setHeaders(%2)").arg(_id), headers);
+
     QDBusPendingReply<> reply =
         _dbusInterface->setHeaders(headers);
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error setting the download headers");
         setLastError(reply.error());
     }
 }
 
 QMap<QString, QString>
 DownloadImpl::headers() {
+    Logger::log(Logger::Debug, QString("Download{%1} headers()").arg(_id));
     QDBusPendingReply<QMap<QString, QString> > reply =
         _dbusInterface->headers();
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error querying the download headers");
         setLastError(reply.error());
         QMap<QString, QString> empty;
         return empty;
@@ -195,22 +273,27 @@
 
 void
 DownloadImpl::setThrottle(qulonglong speed) {
+    Logger::log(Logger::Debug,
+        QString("Download{%1} setThrottle(%2)").arg(_id).arg(speed));
     QDBusPendingReply<> reply =
         _dbusInterface->setThrottle(speed);
     // block, the call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error setting the download throttle");
         setLastError(reply.error());
     }
 }
 
 qulonglong
 DownloadImpl::throttle() {
+    Logger::log(Logger::Debug, QString("Download{%1} throttle()").arg(_id));
     QDBusPendingReply<qulonglong> reply =
         _dbusInterface->throttle();
     // block, the call is fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error querying the download throttle");
         setLastError(reply.error());
         return 0;
     } else {
@@ -226,11 +309,13 @@
 
 QVariantMap
 DownloadImpl::metadata() {
+    Logger::log(Logger::Debug, QString("Download{%1} metadata()").arg(_id));
     QDBusPendingReply<QVariantMap> reply =
         _dbusInterface->metadata();
     // block the call is fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error querying the download metadata");
         QVariantMap emptyResult;
         setLastError(reply.error());
         return emptyResult;
@@ -242,11 +327,13 @@
 
 qulonglong
 DownloadImpl::progress() {
+    Logger::log(Logger::Debug, QString("Download{%1} progress()").arg(_id));
     QDBusPendingReply<qulonglong> reply =
         _dbusInterface->progress();
     // block call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error querying the download progress");
         setLastError(reply.error());
         return 0;
     } else {
@@ -257,11 +344,13 @@
 
 qulonglong
 DownloadImpl::totalSize() {
+    Logger::log(Logger::Debug, QString("Download{%1} totalSize()").arg(_id));
     QDBusPendingReply<qulonglong> reply =
         _dbusInterface->totalSize();
-    // block call should b fast enough
+    // block call should be fast enough
     reply.waitForFinished();
     if (reply.isError()) {
+        Logger::log(Logger::Error, "Error querying the download size");
         setLastError(reply.error());
         return 0;
     } else {

=== modified file 'src/downloads/client/ubuntu/download_manager/download_impl.h'
--- src/downloads/client/ubuntu/download_manager/download_impl.h	2014-07-03 10:39:05 +0000
+++ src/downloads/client/ubuntu/download_manager/download_impl.h	2014-07-03 10:39:06 +0000
@@ -24,11 +24,14 @@
 #include <QObject>
 #include <QVariantMap>
 #include <QString>
+
 #include <ubuntu/transfers/visibility.h>
 #include <ubuntu/download_manager/metatypes.h>
-#include "download_interface.h"
-#include "download_pendingcall_watcher.h"
-#include "error.h"
+
+#include <ubuntu/download_manager/download_interface.h>
+#include <ubuntu/download_manager/download_pendingcall_watcher.h>
+#include <ubuntu/download_manager/error.h>
+
 #include "download.h"
 
 class QDBusConnection;

=== modified file 'src/downloads/client/ubuntu/download_manager/download_pendingcall_watcher.cpp'
--- src/downloads/client/ubuntu/download_manager/download_pendingcall_watcher.cpp	2014-04-09 11:10:26 +0000
+++ src/downloads/client/ubuntu/download_manager/download_pendingcall_watcher.cpp	2014-07-03 10:39:06 +0000
@@ -16,25 +16,33 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <QDebug>
 #include <QDBusPendingReply>
-#include <glog/logging.h>
-#include "error.h"
-#include "download_pendingcall_watcher.h"
+
+#include <boost/log/sources/record_ostream.hpp>
+#include <boost/log/sources/severity_feature.hpp>
+
+#include <ubuntu/download_manager/error.h>
+#include <ubuntu/download_manager/logging/logger.h>
+
+#include <ubuntu/download_manager/download_pendingcall_watcher.h>
 
 namespace Ubuntu {
 
 namespace DownloadManager {
 
-DownloadPCW::DownloadPCW(
-                                               const QDBusConnection& conn,
-                                               const QString& servicePath,
-                                               const QDBusPendingCall& call,
-                                               Download* parent)
+using namespace Logging;
+
+DownloadPCW::DownloadPCW(const QDBusConnection& conn,
+                         const QString& servicePath,
+                         const QDBusPendingCall& call,
+                         Download* parent)
     : PendingCallWatcher(conn, servicePath, call, parent) {
-    CHECK(connect(this, &DownloadPCW::finished,
-        this, &DownloadPCW::onFinished))
-            << "Could not connect to signal";
+    auto connected = connect(this, &DownloadPCW::finished,
+        this, &DownloadPCW::onFinished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadPCW::finished");
+    }
 }
 
 void
@@ -42,7 +50,9 @@
     auto down = qobject_cast<Download*>(parent());
     QDBusPendingReply<> reply = *watcher;
     if (reply.isError()) {
-        qDebug() << "ERROR" << reply.error() << reply.error().type();
+        auto dbusErr = reply.error();
+        Logger::log(Logger::Error,
+            QString("%1 %2").arg(dbusErr.name()).arg(dbusErr.message()));
         auto err = new DBusError(reply.error());
         down->error(err);
     }

=== added directory 'src/downloads/client/ubuntu/download_manager/logging'
=== added file 'src/downloads/client/ubuntu/download_manager/logging/logger.cpp'
--- src/downloads/client/ubuntu/download_manager/logging/logger.cpp	1970-01-01 00:00:00 +0000
+++ src/downloads/client/ubuntu/download_manager/logging/logger.cpp	2014-07-03 10:39:06 +0000
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <boost/log/expressions/attr_fwd.hpp>
+#include <boost/log/expressions/attr.hpp>
+#include <boost/log/expressions/formatters/date_time.hpp>
+#include <boost/log/keywords/channel.hpp>
+#include <boost/log/sources/severity_channel_logger.hpp>
+#include <boost/log/sources/record_ostream.hpp>
+#include <boost/log/support/date_time.hpp>
+#include <boost/log/utility/setup/console.hpp>
+#include <boost/log/utility/setup/file.hpp>
+#include <boost/log/utility/setup/common_attributes.hpp>
+
+#include <ubuntu/download_manager/download_struct.h>
+#include <ubuntu/download_manager/logging/logger.h>
+
+typedef boost::log::sources::severity_channel_logger_mt<
+    Ubuntu::DownloadManager::Logging::Logger::Level,
+    std::string> logger_mt;
+
+namespace {
+    const std::string DOWNLOAD_MANAGER_CHANNEL = "ubuntu_download_manager";
+    void my_formatter(boost::log::record_view const& rec,
+                      boost::log::formatting_ostream& strm) {
+        using namespace Ubuntu::DownloadManager::Logging;
+        // grab the attributes we are interested in
+        strm << boost::log::extract<unsigned int>("LineID", rec) << " [";
+        strm << boost::log::extract<boost::posix_time::ptime>("TimeStamp", rec) << "] ";
+        strm << boost::log::extract<std::string>("Channel", rec) << " [";
+        auto severity = boost::log::extract<Logger::Level>("Severity", rec).get();
+        switch(severity) {
+            case Logger::Debug:
+                strm << "Debug";
+                break;
+            case Logger::Normal:
+                strm << "Normal";
+                break;
+            case Logger::Notification:
+                strm << "Notification";
+                break;
+            case Logger::Warning:
+                strm << "Warning";
+                break;
+            case Logger::Error:
+                strm << "Error";
+                break;
+            default:
+                strm << "Critical";
+                break;
+        }
+        strm << "] ";
+        // Finally, put the record message to the stream
+        strm << rec[boost::log::expressions::smessage];
+    }
+}
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+namespace Logging {
+
+class LoggerPrivate {
+ public:
+    LoggerPrivate() { }
+
+    void init(Logger::Level lvl, const QString& path) {
+        if (_lg == nullptr) {
+            boost::log::add_common_attributes();
+
+            _lg = new logger_mt(
+                boost::log::keywords::channel = DOWNLOAD_MANAGER_CHANNEL,
+                boost::log::keywords::severity = lvl);
+            // create a sink with the given file name and then add a filter
+            // to ensure that just the download manager logs are written in it
+            auto sink  = boost::log::add_file_log(
+                boost::log::keywords::file_name = path.toStdString(),
+                boost::log::keywords::auto_flush = true
+            );
+
+            sink->set_formatter(&my_formatter);
+
+            sink->set_filter
+            (
+                boost::log::expressions::attr<std::string>("Channel") == DOWNLOAD_MANAGER_CHANNEL
+            );
+
+        } else {
+            log(Logger::Critical, "Logger init called more than once.");
+        }
+    }
+
+    void log(Logger::Level lvl, const QString& msg) {
+        if (_lg != nullptr) {
+            auto rec = _lg->open_record(boost::log::keywords::severity = lvl);
+            if (rec) {
+                boost::log::record_ostream strm(rec);
+                strm << msg.toStdString();
+                strm.flush();
+                _lg->push_record(boost::move(rec));
+            }
+        }
+    }
+
+    void log(Logger::Level lvl, const QStringList& msgList) {
+        auto msg = msgList.join(" ");
+        log(lvl, msg);
+    }
+
+    void log(Logger::Level lvl, const QString& msg, QMap<QString, QString> map) {
+        auto fmtMsg = msg.arg(toString(map));
+        log(lvl, fmtMsg);
+    }
+
+    void log(Logger::Level lvl, const QString& msg, DownloadStruct downStruct) {
+        QStringList list;
+
+        list << "\n\t\tUrl: " << downStruct.getUrl()
+             << "\n\t\tHash Algorithm: '" << downStruct.getAlgorithm() << "'"
+             << "\n\t\tMetadata: " << toString(downStruct.getMetadata())
+             << "\n\t\tHeaders: " << toString(downStruct.getHeaders());
+
+        auto fmtMsg = msg.arg(list.join(""));
+        log(lvl, fmtMsg);
+    }
+
+ private:
+    QString toString(QMap<QString, QString> map) {
+        QStringList list;
+        list << "{";
+        int index = map.keys().count();
+        foreach(const QString& key, map.keys()) {
+            list << "'" << key << "': '" << map[key] << "'";
+            if (index != 1) {
+                list << ", ";
+            }
+            index--;
+        }
+        list << "}";
+        return list.join("");
+    }
+
+    QString toString(QVariantMap map) {
+        QStringList list;
+        list << "{";
+        int index = map.keys().count();
+        foreach(const QString& key, map.keys()) {
+            list << "'" << key << "': '"
+                << map[key].toString() << "'";
+    	    if (index != 1) {
+                list << ", ";
+    	    }
+            index--;
+        }
+        list << "}";
+        return list.join("");
+    }
+
+ private:
+    logger_mt* _lg = nullptr;
+};
+
+LoggerPrivate* Logger::_private = new LoggerPrivate();
+QMutex Logger::_mutex;
+
+void
+Logger::init(Logger::Level lvl, const QString& path) {
+    _mutex.lock();
+    _private->init(lvl, path);
+    _mutex.unlock();
+}
+
+void
+Logger::log(Logger::Level lvl, const QString& msg) {
+    _private->log(lvl, msg);
+}
+
+void
+Logger::log(Logger::Level lvl, const QStringList& msg) {
+    _private->log(lvl, msg);
+}
+
+void
+Logger::log(Level lvl, const QString& msg, QMap<QString, QString> map) {
+    _private->log(lvl, msg, map);
+}
+
+void
+Logger::log(Level lvl, const QString& msg, DownloadStruct downStruct) {
+    _private->log(lvl, msg, downStruct);
+}
+
+}  // logging
+
+}  // Transfers
+
+}  // Ubuntu

=== added file 'src/downloads/client/ubuntu/download_manager/logging/logger.h'
--- src/downloads/client/ubuntu/download_manager/logging/logger.h	1970-01-01 00:00:00 +0000
+++ src/downloads/client/ubuntu/download_manager/logging/logger.h	2014-07-03 10:39:06 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2014 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General Public
+ * License 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef UBUNTU_DOWNLOADMANAGER_CLIENT_LOGGER_H
+#define UBUNTU_DOWNLOADMANAGER_CLIENT_LOGGER_H
+
+#include <QMap>
+#include <QMutex>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+
+namespace Ubuntu {
+
+namespace DownloadManager {
+
+class DownloadImpl;
+class DownloadPCW;
+class ManagerImpl;
+class DownloadManagerPCW;
+class DownloadsListManagerPCW;
+class GroupManagerPCW;
+class MetadataDownloadsListManagerPCW;
+class DownloadStruct;
+
+namespace Logging {
+
+class LoggerPrivate;
+
+/*!
+    \class Logger
+    \brief The Logger class allows to control a logging that
+           is performed within the library allowed the developer
+           to set the log level as well as the path of the file
+           where the logs are written.
+    \since 0.5
+
+*/
+class Logger {
+    friend class Ubuntu::DownloadManager::DownloadImpl;
+    friend class Ubuntu::DownloadManager::DownloadPCW;
+    friend class Ubuntu::DownloadManager::ManagerImpl;
+    friend class Ubuntu::DownloadManager::DownloadManagerPCW;
+    friend class Ubuntu::DownloadManager::DownloadsListManagerPCW;
+    friend class Ubuntu::DownloadManager::GroupManagerPCW;
+    friend class Ubuntu::DownloadManager::MetadataDownloadsListManagerPCW;
+
+ public:
+    /*! The different log levels supported by the default logger of the lib. */
+    enum Level
+    {
+        Debug,
+        Normal,
+        Notification,
+        Warning,
+        Error,
+        Critical
+    };
+
+    /*!
+        \fn static void Logger::init(Level lvl, const QString& path)
+
+        Initializes the logging service for the download library using
+        the given \a level and writing the logs to the given \a path.
+    */
+    static void init(Level lvl, const QString& path);
+
+ protected:
+
+    /*! \cond PRIVATE
+     */
+    static void log(Level lvl, const QString& msg);
+    static void log(Level lvl, const QStringList& msg);
+    static void log(Level lvl, const QString& msg, QMap<QString, QString> map);
+    static void log(Level lvl, const QString& msg, DownloadStruct downStruct);
+    /*! \endcond
+     */
+
+ private:
+    static QMutex _mutex;
+    static LoggerPrivate* _private;
+};
+
+}  // Logging
+
+}  // DownloadManager
+
+}  // Ubuntu
+
+#endif

=== modified file 'src/downloads/client/ubuntu/download_manager/manager.cpp'
--- src/downloads/client/ubuntu/download_manager/manager.cpp	2014-02-12 12:01:11 +0000
+++ src/downloads/client/ubuntu/download_manager/manager.cpp	2014-07-03 10:39:06 +0000
@@ -16,9 +16,8 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <QDebug>
-#include "manager_impl.h"
-#include "manager.h"
+#include <ubuntu/download_manager/manager_impl.h>
+#include <ubuntu/download_manager/manager.h>
 
 namespace {
     const QString DOWNLOAD_SERVICE = "com.canonical.applications.Downloader";

=== modified file 'src/downloads/client/ubuntu/download_manager/manager_impl.cpp'
--- src/downloads/client/ubuntu/download_manager/manager_impl.cpp	2014-04-09 11:10:26 +0000
+++ src/downloads/client/ubuntu/download_manager/manager_impl.cpp	2014-07-03 10:39:06 +0000
@@ -16,12 +16,13 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <QDebug>
-#include <glog/logging.h>
-#include "download_impl.h"
-#include "downloads_list.h"
+#include <ubuntu/download_manager/download_impl.h>
+#include <ubuntu/download_manager/downloads_list.h>
+#include <ubuntu/download_manager/logging/logger.h>
+
 #include "manager_impl.h"
 
+
 namespace {
     const QString MANAGER_PATH = "/";
 }
@@ -30,6 +31,8 @@
 
 namespace DownloadManager {
 
+using namespace Logging;
+
 ManagerImpl::ManagerImpl(const QDBusConnection& conn,
                          const QString& path,
                          QObject* parent)
@@ -80,12 +83,14 @@
 
 Download*
 ManagerImpl::getDownloadForId(const QString& id) {
+    Logger::log(Logger::Debug, QString("Manager getDownloadForId(%1)").arg(id));
     auto down = new DownloadImpl(_conn, _servicePath, QDBusObjectPath(id));
     return down;
 }
 
 void
 ManagerImpl::createDownload(DownloadStruct downStruct) {
+    Logger::log(Logger::Debug, "Manager createDownload(%1)", downStruct);
     DownloadCb cb = [](Download*) {};
     createDownload(downStruct, cb, cb);
 }
@@ -98,8 +103,12 @@
         _dbusInterface->createDownload(downStruct);
     auto watcher = new DownloadManagerPCW(_conn,
             _servicePath, call, cb, errCb, this);
-    CHECK(connect(watcher, &DownloadManagerPCW::callbackExecuted,
-        this, &ManagerImpl::onWatcherDone)) << "Could not connect to signal";
+    auto connected = connect(watcher, &DownloadManagerPCW::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadManagerPCW::callbackExecuted,");
+    }
 }
 
 void
@@ -125,28 +134,40 @@
             algorithm, allowed3G, metadata, headers);
     auto watcher = new GroupManagerPCW(_conn, _servicePath,
             call, cb, errCb, this);
-    CHECK(connect(watcher, &GroupManagerPCW::callbackExecuted,
-        this, &ManagerImpl::onWatcherDone)) << "Could not connect to signal";
+    auto connected = connect(watcher, &GroupManagerPCW::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &GroupManagerPCW::callbackExecuted");
+    }
 }
 
 void
 ManagerImpl::getAllDownloads() {
+    Logger::log(Logger::Debug, "Manager getAllDownloads()");
     DownloadsListCb cb = [](DownloadsList*){};
     getAllDownloads(cb, cb);
 }
 
 void
 ManagerImpl::getAllDownloads(DownloadsListCb cb, DownloadsListCb errCb) {
+    Logger::log(Logger::Debug, "Manager getAllDownloads()");
     QDBusPendingCall call = _dbusInterface->getAllDownloads();
     auto watcher = new DownloadsListManagerPCW(
         _conn, _servicePath, call, cb, errCb, this);
-    CHECK(connect(watcher, &GroupManagerPCW::callbackExecuted,
-        this, &ManagerImpl::onWatcherDone)) << "Could not connect to signal";
+    auto connected = connect(watcher, &GroupManagerPCW::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal");
+    }
 }
 
 void
 ManagerImpl::getAllDownloadsWithMetadata(const QString &name,
                                          const QString &value) {
+    Logger::log(Logger::Debug,
+        QString("Manager getAllDownloadsWithMetadata(%1, %2)").arg(name).arg(value));
     MetadataDownloadsListCb cb =
         [](const QString&, const QString&, DownloadsList*){};
     getAllDownloadsWithMetadata(name, value, cb, cb);
@@ -157,12 +178,17 @@
                                          const QString &value,
                                          MetadataDownloadsListCb cb,
                                          MetadataDownloadsListCb errCb) {
+    Logger::log(Logger::Debug,
+        QString("Manager getAllDownloadsWithMetadata(%1, %2)").arg(name).arg(value));
     QDBusPendingCall call = _dbusInterface->getAllDownloadsWithMetadata(
     name, value);
     auto watcher = new MetadataDownloadsListManagerPCW(
         _conn, _servicePath, call, name, value, cb, errCb, this);
-    CHECK(connect(watcher, &GroupManagerPCW::callbackExecuted,
-        this, &ManagerImpl::onWatcherDone)) << "Could not connect to signal";
+    auto connected = connect(watcher, &GroupManagerPCW::callbackExecuted,
+        this, &ManagerImpl::onWatcherDone);
+    if (!connected) {
+        Logger::log(Logger::Critical, "Could not connect to signal");
+    }
 }
 
 bool
@@ -187,27 +213,29 @@
 
 void
 ManagerImpl::allowMobileDataDownload(bool allowed) {
+    Logger::log(Logger::Debug,
+        QString("Manager allowMobileDataDownload(%1)").arg(allowed));
     QDBusPendingReply<> reply =
         _dbusInterface->allowGSMDownload(allowed);
     // we block but because we expect it to be fast
     reply.waitForFinished();
     if (reply.isError()) {
         auto err = reply.error();
-        qCritical() << "Error setting mobile data" << err;
+        Logger::log(Logger::Critical, "Error setting mobile data");
         setLastError(err);
     }
 }
 
 bool
 ManagerImpl::isMobileDataDownload() {
+    Logger::log(Logger::Debug, "Manager isMobileDataDownload()");
     QDBusPendingReply<bool> reply =
         _dbusInterface->isGSMDownloadAllowed();
     // we block but because we expect it to be fast
     reply.waitForFinished();
     if (reply.isError()) {
         auto err = reply.error();
-        qCritical() << "Error getting if mobile data is enabled"
-            << err;
+        Logger::log(Logger::Error, "Error getting if mobile data is enabled");
         setLastError(err);
         return false;
     } else {
@@ -217,13 +245,14 @@
 
 qulonglong
 ManagerImpl::defaultThrottle() {
+    Logger::log(Logger::Debug, "Manager defaultThrottle()");
     QDBusPendingReply<qulonglong> reply =
         _dbusInterface->defaultThrottle();
     // we block but because we expect it to be fast
     reply.waitForFinished();
     if (reply.isError()) {
         auto err = reply.error();
-        qCritical() << "Error getting the default throttle" << err;
+        Logger::log(Logger::Error, "Error getting the default throttle");
         setLastError(err);
         return 0;
     } else {
@@ -233,26 +262,29 @@
 
 void
 ManagerImpl::setDefaultThrottle(qulonglong speed) {
+    Logger::log(Logger::Debug,
+        QString("Manager setDefaultThrottle(%1)").arg(speed));
     QDBusPendingReply<> reply =
         _dbusInterface->setDefaultThrottle(speed);
     // we block but because we expect it to be fast
     reply.waitForFinished();
     if (reply.isError()) {
         auto err = reply.error();
-        qCritical() << "Error setting default throttle" << err;
+        Logger::log(Logger::Error, "Error setting default throttle");
         setLastError(err);
     }
 }
 
 void
 ManagerImpl::exit() {
+    Logger::log(Logger::Debug, "Manager exit()");
     QDBusPendingReply<> reply =
         _dbusInterface->exit();
     // we block but because we expect it to be fast
     reply.waitForFinished();
     if (reply.isError()) {
         auto err = reply.error();
-        qCritical() << "Error setting killing the daemon" << err;
+        Logger::log(Logger::Error, "Error setting killing the daemon");
         setLastError(err);
     }
 }

=== modified file 'src/downloads/client/ubuntu/download_manager/manager_impl.h'
--- src/downloads/client/ubuntu/download_manager/manager_impl.h	2014-06-06 10:05:15 +0000
+++ src/downloads/client/ubuntu/download_manager/manager_impl.h	2014-07-03 10:39:06 +0000
@@ -21,13 +21,16 @@
 
 #include <QDBusConnection>
 #include <QDBusObjectPath>
+
 #include <ubuntu/transfers/visibility.h>
 #include <ubuntu/transfers/system/dbus_connection.h>
-#include "download.h"
-#include "error.h"
-#include "group_download.h"
-#include "manager_interface.h"
-#include "manager_pendingcall_watcher.h"
+
+#include <ubuntu/download_manager/download.h>
+#include <ubuntu/download_manager/error.h>
+#include <ubuntu/download_manager/group_download.h>
+#include <ubuntu/download_manager/manager_interface.h>
+#include <ubuntu/download_manager/manager_pendingcall_watcher.h>
+
 #include "manager.h"
 
 
@@ -108,7 +111,6 @@
     QString _servicePath;
     Error* _lastError = nullptr;
     ManagerInterface* _dbusInterface = nullptr;
-
 };
 
 }  // DownloadManager

=== modified file 'src/downloads/client/ubuntu/download_manager/manager_pendingcall_watcher.cpp'
--- src/downloads/client/ubuntu/download_manager/manager_pendingcall_watcher.cpp	2014-04-09 11:10:26 +0000
+++ src/downloads/client/ubuntu/download_manager/manager_pendingcall_watcher.cpp	2014-07-03 10:39:06 +0000
@@ -16,21 +16,27 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <QDebug>
 #include <QDBusPendingReply>
 #include <QDBusObjectPath>
-#include <glog/logging.h>
-#include "download_impl.h"
-#include "downloads_list_impl.h"
-#include "error.h"
-#include "group_download.h"
-#include "manager.h"
-#include "manager_pendingcall_watcher.h"
+
+#include <boost/log/sources/record_ostream.hpp>
+#include <boost/log/sources/severity_feature.hpp>
+
+#include <ubuntu/download_manager/download_impl.h>
+#include <ubuntu/download_manager/downloads_list_impl.h>
+#include <ubuntu/download_manager/error.h>
+#include <ubuntu/download_manager/group_download.h>
+#include <ubuntu/download_manager/manager.h>
+#include <ubuntu/download_manager/logging/logger.h>
+
+#include <ubuntu/download_manager/manager_pendingcall_watcher.h>
 
 namespace Ubuntu {
 
 namespace DownloadManager {
 
+using namespace Logging;
+
 DownloadManagerPCW::DownloadManagerPCW(const QDBusConnection& conn,
                                        const QString& servicePath,
                                        const QDBusPendingCall& call,
@@ -40,9 +46,12 @@
     : PendingCallWatcher(conn, servicePath, call, parent),
       _cb(cb),
       _errCb(errCb) {
-    CHECK(connect(this, &QDBusPendingCallWatcher::finished,
-        this, &DownloadManagerPCW::onFinished))
-            << "Could not connect to signal";
+    auto connected = connect(this, &QDBusPendingCallWatcher::finished,
+        this, &DownloadManagerPCW::onFinished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &QDBusPendingCallWatcher::finished");
+    }
 }
 
 void
@@ -50,14 +59,14 @@
     QDBusPendingReply<QDBusObjectPath> reply = *watcher;
     auto man = static_cast<Manager*>(parent());
     if (reply.isError()) {
-        qDebug() << "ERROR" << reply.error() << reply.error().type();
-        // create error and deal with it
+        auto dbusErr = reply.error();
+        Logger::log(Logger::Error,
+            QString("%1 %2").arg(dbusErr.name()).arg(dbusErr.message()));
         auto err = new DBusError(reply.error());
         auto down = new DownloadImpl(_conn, err);
         _errCb(down);
         emit man->downloadCreated(down);
     } else {
-        qDebug() << "Success!";
         auto path = reply.value();
         auto down = new DownloadImpl(_conn, _servicePath, path);
         emit man->downloadCreated(down);
@@ -76,8 +85,12 @@
     : PendingCallWatcher(conn, servicePath, call, parent),
       _cb(cb),
       _errCb(errCb) {
-    connect(this, &QDBusPendingCallWatcher::finished,
+    auto connected = connect(this, &QDBusPendingCallWatcher::finished,
         this, &DownloadsListManagerPCW::onFinished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &QDBusPendingCallWatcher::finished");
+    }
 }
 
 void
@@ -86,14 +99,14 @@
     DownloadsListImpl* list;
     auto man = static_cast<Manager*>(parent());
     if (reply.isError()) {
-        qDebug() << "ERROR" << reply.error() << reply.error().type();
-        // create error and deal with it
+        auto dbusErr = reply.error();
+        Logger::log(Logger::Error,
+            QString("%1 %2").arg(dbusErr.name()).arg(dbusErr.message()));
         auto err = new DBusError(reply.error());
         list = new DownloadsListImpl(err);
         _errCb(list);
         emit man->downloadsFound(list);
     } else {
-        qDebug() << "Success!";
         auto paths = reply.value();
         QList<QSharedPointer<Download> > downloads;
         list = new DownloadsListImpl();
@@ -125,8 +138,12 @@
       _value(value),
       _cb(cb),
       _errCb(errCb) {
-    connect(this, &QDBusPendingCallWatcher::finished,
+    auto connected = connect(this, &QDBusPendingCallWatcher::finished,
         this, &MetadataDownloadsListManagerPCW::onFinished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &QDBusPendingCallWatcher::finished");
+    }
 }
 
 void
@@ -135,14 +152,14 @@
     DownloadsListImpl* list;
     auto man = static_cast<Manager*>(parent());
     if (reply.isError()) {
-        qDebug() << "ERROR" << reply.error() << reply.error().type();
-        // create error and deal with it
+        auto dbusErr = reply.error();
+        Logger::log(Logger::Error,
+            QString("%1 %2").arg(dbusErr.name()).arg(dbusErr.message()));
         auto err = new DBusError(reply.error());
         list = new DownloadsListImpl(err);
         _errCb(_key, _value, list);
         emit man->downloadsWithMetadataFound(_key, _value, list);
     } else {
-        qDebug() << "Success!";
         auto paths = reply.value();
         QList<QSharedPointer<Download> > downloads;
         list = new DownloadsListImpl();
@@ -169,9 +186,12 @@
     : PendingCallWatcher(conn, servicePath, call, parent),
       _cb(cb),
       _errCb(errCb) {
-    CHECK(connect(this, &QDBusPendingCallWatcher::finished,
-        this, &GroupManagerPCW::onFinished))
-            << "Could not connect to signal";
+    auto connected = connect(this, &QDBusPendingCallWatcher::finished,
+        this, &GroupManagerPCW::onFinished);
+    if (!connected) {
+        Logger::log(Logger::Critical,
+            "Could not connect to signal &DownloadPCW::finished");
+    }
 }
 
 void
@@ -179,7 +199,9 @@
     QDBusPendingReply<QDBusObjectPath> reply = *watcher;
     auto man = static_cast<Manager*>(parent());
     if (reply.isError()) {
-        // creater error and deal with it
+        auto dbusErr = reply.error();
+        Logger::log(Logger::Error,
+            QString("%1 %2").arg(dbusErr.name()).arg(dbusErr.message()));
         auto err = new DBusError(reply.error());
         auto down = new GroupDownload(err);
         _errCb(down);

=== modified file 'tests/local_tree_testcase.cpp'
--- tests/local_tree_testcase.cpp	2014-03-27 12:54:03 +0000
+++ tests/local_tree_testcase.cpp	2014-07-03 10:39:06 +0000
@@ -48,4 +48,6 @@
 
     QString smallFile = dataDirectory() + "/" + QString(SMALL_FILE);
     addFileToHttpServer(smallFile);
+    Ubuntu::DownloadManager::Logging::Logger::init(
+        Ubuntu::DownloadManager::Logging::Logger::Debug, testDirectory() + "/client.log");
 }

=== modified file 'tests/local_tree_testcase.h'
--- tests/local_tree_testcase.h	2014-03-12 12:59:51 +0000
+++ tests/local_tree_testcase.h	2014-07-03 10:39:06 +0000
@@ -21,6 +21,8 @@
 
 #include <QObject>
 #include <QUrl>
+
+#include <ubuntu/download_manager/logging/logger.h>
 #include "daemon_testcase.h"
 
 class LocalTreeTestCase : public DaemonTestCase {