Index: src/libchcore/TTask.cpp
===================================================================
diff -u -N -rd9527df01ee91b35d9a5fdccb80ded25a9c8265f -re98c03b108baad889dfd7c7fbb1a49f5ea5a55d8
--- src/libchcore/TTask.cpp	(.../TTask.cpp)	(revision d9527df01ee91b35d9a5fdccb80ded25a9c8265f)
+++ src/libchcore/TTask.cpp	(.../TTask.cpp)	(revision e98c03b108baad889dfd7c7fbb1a49f5ea5a55d8)
@@ -28,7 +28,6 @@
 #include "ErrorCodes.h"
 #include "ISerializerRowData.h"
 #include "TStringSet.h"
-#include "SerializerTrace.h"
 #include "TScopedRunningTimeTracker.h"
 #include "TScopedRunningTimeTrackerPause.h"
 #include "TFeedbackHandlerWrapper.h"
@@ -44,15 +43,15 @@
 	// TTask members
 
 	TTask::TTask(const ISerializerPtr& spSerializer, const IFeedbackHandlerPtr& spFeedbackHandler,
-		const TTaskDefinition& rTaskDefinition, const TSmartPath& rLogPath, const logger::TMultiLoggerConfigPtr& spLoggerConfig) :
+		const TTaskDefinition& rTaskDefinition, const logger::TLogFileDataPtr& spLogFileData) :
 		m_spSerializer(spSerializer),
 		m_spInternalFeedbackHandler(spFeedbackHandler),
-		m_spLog(std::make_unique<logger::TLogger>(logger::TAsyncMultiLogger::GetInstance()->CreateLoggerData(rLogPath.ToString(), spLoggerConfig), L"Task")),
+		m_spLog(logger::MakeLogger(spLogFileData, L"Task")),
 		m_spSrcPaths(new TBasePathDataContainer),
 		m_tSubTasksArray(m_tSubTaskContext),
 		m_tSubTaskContext(m_tConfiguration, m_spSrcPaths, m_afFilters,
-		                  m_cfgTracker, m_spLog->GetLogFileData(), m_workerThread,
-		                  std::make_shared<TLocalFilesystem>(m_spLog->GetLogFileData())),
+		                  m_cfgTracker, spLogFileData, m_workerThread,
+		                  std::make_shared<TLocalFilesystem>(spLogFileData)),
 		m_bForce(false),
 		m_bContinue(false)
 	{
@@ -61,14 +60,13 @@
 		if(!spSerializer)
 			throw TCoreException(eErr_InvalidArgument, L"spSerializer", LOCATION);
 
-		m_tBaseData.SetLogPath(rLogPath);
 		SetTaskDefinition(rTaskDefinition);
 	}
 
-	TTask::TTask(const ISerializerPtr& spSerializer, const IFeedbackHandlerPtr& spFeedbackHandler, const TTaskBaseData& rBaseTaskData, const logger::TMultiLoggerConfigPtr& spLoggerConfig) :
+	TTask::TTask(const ISerializerPtr& spSerializer, const IFeedbackHandlerPtr& spFeedbackHandler, const logger::TLogFileDataPtr& spLogFileData) :
 		m_spSerializer(spSerializer),
 		m_spInternalFeedbackHandler(spFeedbackHandler),
-		m_spLog(std::make_unique<logger::TLogger>(logger::TAsyncMultiLogger::GetInstance()->CreateLoggerData(rBaseTaskData.GetLogPath().ToString(), spLoggerConfig), L"Task")),
+		m_spLog(logger::MakeLogger(spLogFileData, L"Task")),
 		m_spSrcPaths(new TBasePathDataContainer),
 		m_tSubTasksArray(m_tSubTaskContext),
 		m_tSubTaskContext(m_tConfiguration, m_spSrcPaths, m_afFilters,
@@ -141,9 +139,8 @@
 		SetTaskPropValue<eTO_ThreadPriority>(m_tConfiguration, nPriority);
 	}
 
-	void TTask::Load(const TTaskBaseData& rBaseData)
+	void TTask::Load()
 	{
-		bool bLogPathLoaded = false;
 		bool bLoadFailed = false;
 		const size_t stMaxSize = 1024;
 		wchar_t szErr[stMaxSize];
@@ -153,10 +150,8 @@
 			boost::unique_lock<boost::shared_mutex> lock(m_lock);
 
 			ISerializerContainerPtr spContainer = m_spSerializer->GetContainer(_T("task"));
-			m_tBaseData = rBaseData;// .Load(spContainer);
+			m_tBaseData.Load(spContainer);
 
-			bLogPathLoaded = true;
-
 			spContainer = m_spSerializer->GetContainer(_T("base_paths"));
 			m_spSrcPaths->Load(spContainer);
 
@@ -202,38 +197,31 @@
 		{
 			try
 			{
-				if (bLogPathLoaded)
-				{
-					LOG_ERROR(m_spLog) << szErr;
-				}
+				LOG_ERROR(m_spLog) << szErr;
 			}
 			catch (const std::exception&)
 			{
 			}
 		}
 	}
 
-	TTaskPtr TTask::Load(const ISerializerPtr& spSerializer, const IFeedbackHandlerPtr& spFeedbackHandler, const logger::TMultiLoggerConfigPtr& spLoggerConfig)
+	TTaskPtr TTask::Load(const ISerializerPtr& spSerializer, const IFeedbackHandlerPtr& spFeedbackHandler, const logger::TLogFileDataPtr& spLogFileData)
 	{
-		TTaskBaseData tBaseData;
-		ISerializerContainerPtr spContainer = spSerializer->GetContainer(_T("task"));
-		tBaseData.Load(spContainer);
+		TTaskPtr spTask = std::shared_ptr<TTask>(new TTask(spSerializer, spFeedbackHandler, spLogFileData));
+		spTask->Load();
 
-		TTaskPtr spTask = std::shared_ptr<TTask>(new TTask(spSerializer, spFeedbackHandler, tBaseData, spLoggerConfig));
-		spTask->Load(tBaseData);
-
 		return spTask;
 	}
 
 	void TTask::Store(bool bForce)
 	{
 		if (GetTaskState() == eTaskState_LoadError)
 		{
-			DBTRACE0(_T("Task::Store() - not storing task as it was not loaded correctly\n"));
+			LOG_DEBUG(m_spLog) << L"Task::Store() - not storing task as it was not loaded correctly";
 			return;
 		}
 
-		DBTRACE0(_T("###### Task::Store() - starting\n"));
+		LOG_DEBUG(m_spLog) << L"Task::Store() - starting";
 
 		// ensure we're only running one serialization of this task at a time;
 		// (this is usually called from the gui thread (on timer) and at specific points
@@ -242,15 +230,15 @@
 		{
 			if (!m_mutexSerializer.try_lock())
 			{
-				DBTRACE0(_T("###### Task::Store() - serialization already running. Skipping.\n"));
+				LOG_DEBUG(m_spLog) << L"Task::Store() - serialization already running. Skipping.";
 				return;
 			}
 		}
 		else
 		{
 			if (!m_mutexSerializer.try_lock())
 			{
-				DBTRACE0(_T("###### Task::Store() - waiting for serialization mutex...\n"));
+				LOG_DEBUG(m_spLog) << L"Task::Store() - waiting for serialization mutex...";
 				m_mutexSerializer.lock();
 			}
 		}
@@ -294,7 +282,7 @@
 		m_spSerializer->Flush();
 
 		unsigned long long ullFlushTime = timer.Stop(); ullFlushTime;
-		DBTRACE2(_T("###### Task::Store() - finished - gather: %I64u ms, flush: %I64u ms\n"), ullGatherTime, ullFlushTime);
+		LOG_DEBUG(m_spLog) << L"Task::Store() - finished - gather: " << ullGatherTime << L" ms, flush: " << ullFlushTime << L" ms";
 	}
 
 	void TTask::KillThread()
@@ -715,7 +703,8 @@
 
 	TSmartPath TTask::GetLogPath() const
 	{
-		return m_tBaseData.GetLogPath();
+		std::wstring wstrPath = m_spLog->GetLogFilePath();
+		return PathFromString(wstrPath.c_str());
 	}
 
 	void TTask::GetLogPaths(logger::TLoggerPaths& rLogPaths) const
@@ -729,11 +718,6 @@
 		return m_tBaseData.GetTaskName();
 	}
 
-	void TTask::SetLogPath(const TSmartPath& pathLog)
-	{
-		m_tBaseData.SetLogPath(pathLog);
-	}
-
 	ISerializerPtr TTask::GetSerializer() const
 	{
 		return m_spSerializer;