Merge branch 'feature/boost_datetime_implementation' into feature/3rd_party_travis_cache

57 files changed, 496 insertions, 676 deletions

diff --git a/src/3rd_party/CMakeLists.txt b/src/3rd_party/CMakeLists.txt
index 3072462ec4..627642f87c 100644
--- a/src/3rd_party/CMakeLists.txt
+++ b/src/3rd_party/CMakeLists.txt
@@ -212,7 +212,7 @@ endif()
 set(BOOST_ROOT ${3RD_PARTY_INSTALL_PREFIX})
 set(BOOST_LIBRARYDIR ${3RD_PARTY_INSTALL_PREFIX}/lib)
 set(BOOST_INCLUDEDIR ${3RD_PARTY_INSTALL_PREFIX}/include)
-find_package(Boost 1.66.0 COMPONENTS system thread) 
+find_package(Boost 1.66.0 COMPONENTS system thread date_time) 
 set(BOOST_LIB_SOURCE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/boost_src)
 SET_PROPERTY(GLOBAL PROPERTY GLOBAL_BOOST_LIBS ${BOOST_LIBRARYDIR})
 if (NOT ${Boost_FOUND})
@@ -227,9 +227,9 @@ if (NOT ${Boost_FOUND})
     URL https://dl.bintray.com/boostorg/release/1.66.0/source/boost_1_66_0.tar.gz
     DOWNLOAD_DIR ${BOOST_LIB_SOURCE_DIRECTORY}
     SOURCE_DIR ${BOOST_LIB_SOURCE_DIRECTORY}
-    CONFIGURE_COMMAND ./bootstrap.sh --with-libraries=system,thread --prefix=${3RD_PARTY_INSTALL_PREFIX}
+    CONFIGURE_COMMAND ./bootstrap.sh --with-libraries=system,thread,date_time --prefix=${3RD_PARTY_INSTALL_PREFIX}
     BUILD_COMMAND ./b2
-    INSTALL_COMMAND ${BOOST_INSTALL_COMMAND} --with-system --with-thread --prefix=${3RD_PARTY_INSTALL_PREFIX} > boost_install.log
+    INSTALL_COMMAND ${BOOST_INSTALL_COMMAND} --with-system --with-thread --with-date_time --prefix=${3RD_PARTY_INSTALL_PREFIX} > boost_install.log
     INSTALL_DIR ${3RD_PARTY_INSTALL_PREFIX}
     BUILD_IN_SOURCE true
   )
diff --git a/src/components/application_manager/include/application_manager/application_impl.h b/src/components/application_manager/include/application_manager/application_impl.h
index d86203cd84..f937ebebe1 100644
--- a/src/components/application_manager/include/application_manager/application_impl.h
+++ b/src/components/application_manager/include/application_manager/application_impl.h
@@ -513,7 +513,7 @@ class ApplicationImpl : public virtual Application,
   /**
    * @brief Defines number per time in seconds limits
    */
-  typedef std::pair<TimevalStruct, uint32_t> TimeToNumberLimit;
+  typedef std::pair<date_time::TimeDuration, uint32_t> TimeToNumberLimit;
 
   /**
    * @brief Defines specific command number per time in seconds limits
diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index 981da8e672..b169839f23 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -1360,7 +1360,7 @@ class ApplicationManagerImpl
    * @brief Map contains applications which
    * will send TTS global properties to HMI after timeout
    */
-  std::map<uint32_t, TimevalStruct> tts_global_properties_app_list_;
+  std::map<uint32_t, date_time::TimeDuration> tts_global_properties_app_list_;
 
   bool audio_pass_thru_active_;
   uint32_t audio_pass_thru_app_id_;
diff --git a/src/components/application_manager/include/application_manager/request_info.h b/src/components/application_manager/include/application_manager/request_info.h
index db6409bbde..57b6986af0 100644
--- a/src/components/application_manager/include/application_manager/request_info.h
+++ b/src/components/application_manager/include/application_manager/request_info.h
@@ -62,7 +62,7 @@ struct RequestInfo {
       , app_id_(0)
       , requst_type_(RequestNone)
       , correlation_id_(0) {
-    start_time_ = date_time::DateTime::getCurrentTime();
+    start_time_ = date_time::getCurrentTime();
     updateEndTime();
   }
   virtual ~RequestInfo() {}
@@ -71,14 +71,14 @@ struct RequestInfo {
               const RequestType requst_type,
               const uint64_t timeout_msec)
       : request_(request), timeout_msec_(timeout_msec), correlation_id_(0) {
-    start_time_ = date_time::DateTime::getCurrentTime();
+    start_time_ = date_time::getCurrentTime();
     updateEndTime();
     requst_type_ = requst_type;
   }
 
   RequestInfo(RequestPtr request,
               const RequestType requst_type,
-              const TimevalStruct& start_time,
+              const date_time::TimeDuration& start_time,
               const uint64_t timeout_msec);
 
   void updateEndTime();
@@ -87,11 +87,11 @@ struct RequestInfo {
 
   bool isExpired();
 
-  TimevalStruct start_time() {
+  date_time::TimeDuration start_time() {
     return start_time_;
   }
 
-  void update_start_time(TimevalStruct start_time) {
+  void update_start_time(date_time::TimeDuration start_time) {
     start_time_ = start_time;
   }
 
@@ -103,7 +103,7 @@ struct RequestInfo {
     timeout_msec_ = timeout;
   }
 
-  TimevalStruct end_time() {
+  date_time::TimeDuration end_time() {
     return end_time_;
   }
 
@@ -128,9 +128,9 @@ struct RequestInfo {
 
  protected:
   RequestPtr request_;
-  TimevalStruct start_time_;
+  date_time::TimeDuration start_time_;
   uint64_t timeout_msec_;
-  TimevalStruct end_time_;
+  date_time::TimeDuration end_time_;
   uint32_t app_id_;
   RequestType requst_type_;
   uint32_t correlation_id_;
@@ -141,14 +141,14 @@ typedef std::shared_ptr<RequestInfo> RequestInfoPtr;
 struct MobileRequestInfo : public RequestInfo {
   MobileRequestInfo(RequestPtr request, const uint64_t timeout_msec);
   MobileRequestInfo(RequestPtr request,
-                    const TimevalStruct& start_time,
+                    const date_time::TimeDuration& start_time,
                     const uint64_t timeout_msec);
 };
 
 struct HMIRequestInfo : public RequestInfo {
   HMIRequestInfo(RequestPtr request, const uint64_t timeout_msec);
   HMIRequestInfo(RequestPtr request,
-                 const TimevalStruct& start_time,
+                 const date_time::TimeDuration& start_time,
                  const uint64_t timeout_msec);
 };
 
@@ -270,8 +270,8 @@ class RequestInfoSet {
 * during time scale
 */
 struct TimeScale {
-  TimeScale(const TimevalStruct& start,
-            const TimevalStruct& end,
+  TimeScale(const date_time::TimeDuration& start,
+            const date_time::TimeDuration& end,
             const uint32_t& app_id)
       : start_(start), end_(end), app_id_(app_id) {}
 
@@ -292,8 +292,8 @@ struct TimeScale {
   }
 
  private:
-  TimevalStruct start_;
-  TimevalStruct end_;
+  date_time::TimeDuration start_;
+  date_time::TimeDuration end_;
   uint32_t app_id_;
 };
 
diff --git a/src/components/application_manager/include/application_manager/request_tracker.h b/src/components/application_manager/include/application_manager/request_tracker.h
index 36ab3eaefb..b351e716a7 100644
--- a/src/components/application_manager/include/application_manager/request_tracker.h
+++ b/src/components/application_manager/include/application_manager/request_tracker.h
@@ -85,7 +85,7 @@ class RequestTracker {
                     const mobile_apis::HMILevel::eType level);
 
  private:
-  typedef std::vector<TimevalStruct> RequestAddedAt;
+  typedef std::vector<date_time::TimeDuration> RequestAddedAt;
   typedef std::map<ApplicationID, RequestAddedAt> ApplicationsRequestsTracker;
 
   /**
diff --git a/src/components/application_manager/include/application_manager/telemetry_observer.h b/src/components/application_manager/include/application_manager/telemetry_observer.h
index 62169e8185..49f15165db 100644
--- a/src/components/application_manager/include/application_manager/telemetry_observer.h
+++ b/src/components/application_manager/include/application_manager/telemetry_observer.h
@@ -44,8 +44,8 @@ namespace application_manager {
 class AMTelemetryObserver {
  public:
   struct MessageMetric {
-    TimevalStruct begin;
-    TimevalStruct end;
+    date_time::TimeDuration begin;
+    date_time::TimeDuration end;
     std::shared_ptr<smart_objects::SmartObject> message;
   };
   typedef std::shared_ptr<MessageMetric> MessageMetricSharedPtr;
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h
index b36f47f260..9b16a2c4da 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h
@@ -107,7 +107,7 @@ class InteriorDataManagerImpl : public InteriorDataManager {
    * @brief RequestsToHMIHistory mapping from module type to vector of time
    * stamps
    */
-  typedef std::map<std::string, std::deque<TimevalStruct> >
+  typedef std::map<std::string, std::deque<date_time::TimeDuration> >
       RequestsToHMIHistory;
   RequestsToHMIHistory requests_to_hmi_history_;
   mutable sync_primitives::Lock requests_to_hmi_history_lock_;
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc
index 28ed2cd941..0c42f6e3de 100644
--- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc
@@ -52,8 +52,7 @@ void InteriorDataManagerImpl::StoreRequestToHMITime(
     const std::string& module_type) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock autolock(requests_to_hmi_history_lock_);
-  requests_to_hmi_history_[module_type].push_back(
-      date_time::DateTime::getCurrentTime());
+  requests_to_hmi_history_[module_type].push_back(date_time::getCurrentTime());
 }
 
 bool InteriorDataManagerImpl::CheckRequestsToHMIFrequency(
@@ -129,9 +128,9 @@ void InteriorDataManagerImpl::UnsubscribeFromInteriorVehicleData(
 void InteriorDataManagerImpl::ClearOldRequestsToHMIHistory() {
   auto limit =
       app_mngr_.get_settings().get_interior_vehicle_data_frequency().second;
-  uint32_t time_frame = limit * date_time::DateTime::MILLISECONDS_IN_SECOND;
-  auto lest_that_time_frame_ago = [time_frame](TimevalStruct time) {
-    auto span = date_time::DateTime::calculateTimeSpan(time);
+  uint32_t time_frame = limit * date_time::MILLISECONDS_IN_SECOND;
+  auto lest_that_time_frame_ago = [time_frame](date_time::TimeDuration time) {
+    auto span = date_time::calculateTimeSpan(time);
     return span < time_frame;
   };
   for (auto& it : requests_to_hmi_history_) {
diff --git a/src/components/application_manager/src/app_launch/app_launch_data_json.cc b/src/components/application_manager/src/app_launch/app_launch_data_json.cc
index 9179f2c08b..d3e3b7d445 100644
--- a/src/components/application_manager/src/app_launch/app_launch_data_json.cc
+++ b/src/components/application_manager/src/app_launch/app_launch_data_json.cc
@@ -131,7 +131,7 @@ bool AppLaunchDataJson::RefreshAppSessionTime(const ApplicationData& app_data) {
   if (index != NotFound) {
     if (json_data_list.empty() == false) {
       json_data_list[index][strings::app_launch_last_session] =
-          static_cast<Json::Value::UInt64>(DateTime::getCurrentTime().tv_sec);
+          static_cast<Json::Value::UInt64>(getSecs(getCurrentTime()));
       retVal = true;
     }
   }
@@ -150,7 +150,7 @@ bool AppLaunchDataJson::AddNewAppData(const ApplicationData& app_data) {
   json_app_data[strings::app_id] = app_data.mobile_app_id_;
   json_app_data[strings::bundle_id] = app_data.bundle_id_;
   json_app_data[strings::app_launch_last_session] =
-      static_cast<Json::Value::UInt64>(DateTime::getCurrentTime().tv_sec);
+      static_cast<Json::Value::UInt64>(getSecs(getCurrentTime()));
 
   LOG4CXX_DEBUG(logger_,
                 "New application data saved. Detatils device_id: "
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index 8f76d81104..1168d94245 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -146,9 +146,9 @@ ApplicationImpl::ApplicationImpl(
     , button_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , application_manager_(application_manager) {
   cmd_number_to_time_limits_[mobile_apis::FunctionID::ReadDIDID] = {
-      date_time::DateTime::getCurrentTime(), 0};
+      date_time::getCurrentTime(), 0};
   cmd_number_to_time_limits_[mobile_apis::FunctionID::GetVehicleDataID] = {
-      date_time::DateTime::getCurrentTime(), 0};
+      date_time::getCurrentTime(), 0};
 
   set_mobile_app_id(mobile_app_id);
   set_name(app_name);
@@ -806,7 +806,7 @@ HelpPromptManager& ApplicationImpl::help_prompt_manager() {
 
 bool ApplicationImpl::AreCommandLimitsExceeded(
     mobile_apis::FunctionID::eType cmd_id, TLimitSource source) {
-  TimevalStruct current = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current = date_time::getCurrentTime();
   switch (source) {
     // In case of config file values there is COMMON limitations for number of
     // commands per certain time in seconds, i.e. 5 requests per 10 seconds with
@@ -838,13 +838,14 @@ bool ApplicationImpl::AreCommandLimitsExceeded(
 
       LOG4CXX_INFO(logger_,
                    "Time Info: "
-                       << "\n Current: " << current.tv_sec << "\n Limit: ("
-                       << limit.first.tv_sec << "," << limit.second
-                       << ")"
-                          "\n frequency_restrictions: ("
+                       << "\n Current: " << date_time::getSecs(current)
+                       << "\n Limit: (" << date_time::getSecs(limit.first)
+                       << "," << limit.second << ")"
+                                                 "\n frequency_restrictions: ("
                        << frequency_restrictions.first << ","
                        << frequency_restrictions.second << ")");
-      if (current.tv_sec < limit.first.tv_sec + frequency_restrictions.second) {
+      if (date_time::getSecs(current) <
+          date_time::getSecs(limit.first) + frequency_restrictions.second) {
         if (limit.second < frequency_restrictions.first) {
           ++limit.second;
           return false;
@@ -886,7 +887,8 @@ bool ApplicationImpl::AreCommandLimitsExceeded(
       TimeToNumberLimit& limit = it->second;
 
       // Checking even limitation for command
-      if (static_cast<uint32_t>(current.tv_sec - limit.first.tv_sec) <
+      if (static_cast<uint32_t>(date_time::getSecs(current) -
+                                date_time::getSecs(limit.first)) <
           minute / cmd_limit) {
         return true;
       }
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 55112e153c..c40b5292ca 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -65,7 +65,6 @@
 #include "utils/threads/thread.h"
 #include "utils/file_system.h"
 #include "utils/helpers.h"
-
 #include "utils/timer_task_impl.h"
 #include "smart_objects/enum_schema_item.h"
 #include "interfaces/HMI_API_schema.h"
@@ -3088,14 +3087,14 @@ void ApplicationManagerImpl::OnTimerSendTTSGlobalProperties() {
   std::vector<uint32_t> app_list;
   {
     sync_primitives::AutoLock lock(tts_global_properties_app_list_lock_);
-    std::map<uint32_t, TimevalStruct>::iterator it =
+    std::map<uint32_t, date_time::TimeDuration>::iterator it =
         tts_global_properties_app_list_.begin();
-    std::map<uint32_t, TimevalStruct>::iterator it_end =
+    std::map<uint32_t, date_time::TimeDuration>::iterator it_end =
         tts_global_properties_app_list_.end();
     date_time::TimeCompare time_comp;
     for (; it != it_end; ++it) {
-      time_comp = date_time::DateTime::compareTime(
-          date_time::DateTime::getCurrentTime(), it->second);
+      time_comp =
+          date_time::compareTime(date_time::getCurrentTime(), it->second);
       if (date_time::GREATER == time_comp || date_time::EQUAL == time_comp) {
         app_list.push_back(it->first);
       }
@@ -3116,8 +3115,8 @@ void ApplicationManagerImpl::AddAppToTTSGlobalPropertiesList(
     const uint32_t app_id) {
   LOG4CXX_AUTO_TRACE(logger_);
   uint16_t timeout = get_settings().tts_global_properties_timeout();
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
-  current_time.tv_sec += timeout;
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
+  current_time += date_time::seconds(timeout);
   // please avoid AutoLock usage to avoid deadlock
   tts_global_properties_app_list_lock_.Acquire();
   if (tts_global_properties_app_list_.end() ==
@@ -3140,7 +3139,7 @@ void ApplicationManagerImpl::RemoveAppFromTTSGlobalPropertiesList(
   LOG4CXX_AUTO_TRACE(logger_);
   // please avoid AutoLock usage to avoid deadlock
   tts_global_properties_app_list_lock_.Acquire();
-  std::map<uint32_t, TimevalStruct>::iterator it =
+  std::map<uint32_t, date_time::TimeDuration>::iterator it =
       tts_global_properties_app_list_.find(app_id);
   if (tts_global_properties_app_list_.end() != it) {
     tts_global_properties_app_list_.erase(it);
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index 05e9d6cb2c..bba68ef0e5 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -658,9 +658,9 @@ void PolicyHandler::OnAppPermissionConsentInternal(
 
 void policy::PolicyHandler::SetDaysAfterEpoch() {
   POLICY_LIB_CHECK_VOID();
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
   const int kSecondsInDay = 60 * 60 * 24;
-  int days_after_epoch = current_time.tv_sec / kSecondsInDay;
+  int days_after_epoch = date_time::getSecs(current_time) / kSecondsInDay;
   PTUpdatedAt(Counters::DAYS_AFTER_EPOCH, days_after_epoch);
 }
 
@@ -1458,7 +1458,7 @@ void PolicyHandler::OnSnapshotCreated(
   std::string policy_snapshot_full_path;
   if (SaveSnapshot(pt_string, policy_snapshot_full_path)) {
     const uint32_t timeout_exchange_s =
-        timeout_exchange_ms / date_time::DateTime::MILLISECONDS_IN_SECOND;
+        timeout_exchange_ms / date_time::MILLISECONDS_IN_SECOND;
     MessageHelper::SendPolicyUpdate(policy_snapshot_full_path,
                                     timeout_exchange_s,
                                     retry_delay_seconds,
@@ -1587,7 +1587,7 @@ uint32_t PolicyHandler::NextRetryTimeout() {
 }
 
 uint32_t PolicyHandler::TimeoutExchangeSec() const {
-  return TimeoutExchangeMSec() / date_time::DateTime::MILLISECONDS_IN_SECOND;
+  return TimeoutExchangeMSec() / date_time::MILLISECONDS_IN_SECOND;
 }
 
 uint32_t PolicyHandler::TimeoutExchangeMSec() const {
diff --git a/src/components/application_manager/src/request_controller.cc b/src/components/application_manager/src/request_controller.cc
index 1c103b13af..28c773ffcb 100644
--- a/src/components/application_manager/src/request_controller.cc
+++ b/src/components/application_manager/src/request_controller.cc
@@ -407,11 +407,11 @@ void RequestController::TimeoutThread() {
                         << " request id: " << probably_expired->requestId()
                         << " connection_key: " << probably_expired->app_id()
                         << " NOT expired");
-      const TimevalStruct current_time = date_time::DateTime::getCurrentTime();
-      const TimevalStruct end_time = probably_expired->end_time();
+      const date_time::TimeDuration current_time = date_time::getCurrentTime();
+      const date_time::TimeDuration end_time = probably_expired->end_time();
       if (current_time < end_time) {
-        const uint32_t msecs = static_cast<uint32_t>(
-            date_time::DateTime::getmSecs(end_time - current_time));
+        const uint32_t msecs =
+            static_cast<uint32_t>(date_time::getmSecs(end_time - current_time));
         LOG4CXX_DEBUG(logger_, "Sleep for " << msecs << " millisecs");
         timer_condition_.WaitFor(auto_lock, msecs);
       }
diff --git a/src/components/application_manager/src/request_info.cc b/src/components/application_manager/src/request_info.cc
index 04210a7572..45e56c5f9e 100644
--- a/src/components/application_manager/src/request_info.cc
+++ b/src/components/application_manager/src/request_info.cc
@@ -51,7 +51,7 @@ HMIRequestInfo::HMIRequestInfo(RequestPtr request, const uint64_t timeout_msec)
 }
 
 HMIRequestInfo::HMIRequestInfo(RequestPtr request,
-                               const TimevalStruct& start_time,
+                               const date_time::TimeDuration& start_time,
                                const uint64_t timeout_msec)
     : RequestInfo(request, HMIRequest, start_time, timeout_msec) {
   correlation_id_ = request_->correlation_id();
@@ -66,7 +66,7 @@ MobileRequestInfo::MobileRequestInfo(RequestPtr request,
 }
 
 MobileRequestInfo::MobileRequestInfo(RequestPtr request,
-                                     const TimevalStruct& start_time,
+                                     const date_time::TimeDuration& start_time,
                                      const uint64_t timeout_msec)
     : RequestInfo(request, MobileRequest, start_time, timeout_msec) {
   correlation_id_ = request_.get()->correlation_id();
@@ -75,7 +75,7 @@ MobileRequestInfo::MobileRequestInfo(RequestPtr request,
 
 RequestInfo::RequestInfo(RequestPtr request,
                          const RequestInfo::RequestType requst_type,
-                         const TimevalStruct& start_time,
+                         const date_time::TimeDuration& start_time,
                          const uint64_t timeout_msec)
     : request_(request), start_time_(start_time), timeout_msec_(timeout_msec) {
   updateEndTime();
@@ -85,8 +85,8 @@ RequestInfo::RequestInfo(RequestPtr request,
 }
 
 void application_manager::request_controller::RequestInfo::updateEndTime() {
-  end_time_ = date_time::DateTime::getCurrentTime();
-  date_time::DateTime::AddMilliseconds(end_time_, timeout_msec_);
+  end_time_ = date_time::getCurrentTime();
+  date_time::AddMilliseconds(end_time_, timeout_msec_);
 }
 
 void RequestInfo::updateTimeOut(const uint64_t& timeout_msec) {
@@ -95,9 +95,8 @@ void RequestInfo::updateTimeOut(const uint64_t& timeout_msec) {
 }
 
 bool RequestInfo::isExpired() {
-  TimevalStruct curr_time = date_time::DateTime::getCurrentTime();
-  return date_time::DateTime::getmSecs(end_time_) <=
-         date_time::DateTime::getmSecs(curr_time);
+  date_time::TimeDuration curr_time = date_time::getCurrentTime();
+  return date_time::getmSecs(end_time_) <= date_time::getmSecs(curr_time);
 }
 
 uint64_t RequestInfo::hash() {
@@ -283,7 +282,7 @@ bool RequestInfoSet::AppIdCompararator::operator()(
 bool RequestInfoTimeComparator::operator()(const RequestInfoPtr lhs,
                                            const RequestInfoPtr rhs) const {
   date_time::TimeCompare compare_result =
-      date_time::DateTime::compareTime(lhs->end_time(), rhs->end_time());
+      date_time::compareTime(lhs->end_time(), rhs->end_time());
   if (compare_result == date_time::LESS) {
     return true;
   } else if (compare_result == date_time::GREATER) {
diff --git a/src/components/application_manager/src/request_tracker.cc b/src/components/application_manager/src/request_tracker.cc
index 13b3d4d873..c047c82579 100644
--- a/src/components/application_manager/src/request_tracker.cc
+++ b/src/components/application_manager/src/request_tracker.cc
@@ -77,7 +77,7 @@ bool RequestTracker::Track(const ApplicationID& app_id,
                            const uint32_t max_requests,
                            ApplicationsRequestsTracker& tracker) {
   LOG4CXX_AUTO_TRACE(logger_);
-  using date_time::DateTime;
+  using namespace date_time;
 
   if (!time_scale || !max_requests) {
     LOG4CXX_INFO(logger_, "Time scale request tracking is disabled.");
@@ -93,7 +93,7 @@ bool RequestTracker::Track(const ApplicationID& app_id,
 
   if (tracker.end() == it_app) {
     LOG4CXX_DEBUG(logger_, "Adding new application into tracking.");
-    tracker[app_id].push_back(DateTime::getCurrentTime());
+    tracker[app_id].push_back(getCurrentTime());
     return true;
   }
 
@@ -102,25 +102,24 @@ bool RequestTracker::Track(const ApplicationID& app_id,
 
   if (it_app->second.size() < max_requests) {
     LOG4CXX_DEBUG(logger_, "Adding new request into tracking.");
-    tracker[app_id].push_back(DateTime::getCurrentTime());
+    tracker[app_id].push_back(getCurrentTime());
     return true;
   }
 
   LOG4CXX_DEBUG(logger_,
                 "Oldest request is added at: "
-                    << DateTime::getmSecs(it_app->second.front())
-                    << ". Current time is: "
-                    << DateTime::getmSecs(DateTime::getCurrentTime())
+                    << getmSecs(it_app->second.front())
+                    << ". Current time is: " << getmSecs(getCurrentTime())
                     << ". Time scale is: " << time_scale);
 
-  if (DateTime::calculateTimeSpan(it_app->second.front()) > time_scale) {
+  if (calculateTimeSpan(it_app->second.front()) > time_scale) {
     LOG4CXX_DEBUG(logger_, "Dropping oldest request, adding new one.");
     ApplicationsRequestsTracker::mapped_type& times = tracker[app_id];
 
     DCHECK_OR_RETURN(!times.empty(), false);
 
     times.erase(times.begin());
-    times.push_back(DateTime::getCurrentTime());
+    times.push_back(getCurrentTime());
     return true;
   }
 
diff --git a/src/components/application_manager/src/rpc_handler_impl.cc b/src/components/application_manager/src/rpc_handler_impl.cc
index 9c2aa497d6..a605795b6e 100644
--- a/src/components/application_manager/src/rpc_handler_impl.cc
+++ b/src/components/application_manager/src/rpc_handler_impl.cc
@@ -59,7 +59,7 @@ void RPCHandlerImpl::ProcessMessageFromMobile(
 #ifdef TELEMETRY_MONITOR
   AMTelemetryObserver::MessageMetricSharedPtr metric(
       new AMTelemetryObserver::MessageMetric());
-  metric->begin = date_time::DateTime::getCurrentTime();
+  metric->begin = date_time::getCurrentTime();
 #endif  // TELEMETRY_MONITOR
   smart_objects::SmartObjectSPtr so_from_mobile =
       std::make_shared<smart_objects::SmartObject>();
@@ -83,7 +83,7 @@ void RPCHandlerImpl::ProcessMessageFromMobile(
     LOG4CXX_ERROR(logger_, "Received command didn't run successfully");
   }
 #ifdef TELEMETRY_MONITOR
-  metric->end = date_time::DateTime::getCurrentTime();
+  metric->end = date_time::getCurrentTime();
   if (metric_observer_) {
     metric_observer_->OnMessage(metric);
   }
diff --git a/src/components/application_manager/test/app_launch/app_launch_data_json_test.cc b/src/components/application_manager/test/app_launch/app_launch_data_json_test.cc
index f68ad32bbb..4541970c70 100644
--- a/src/components/application_manager/test/app_launch/app_launch_data_json_test.cc
+++ b/src/components/application_manager/test/app_launch/app_launch_data_json_test.cc
@@ -36,7 +36,6 @@
 #include "json/json.h"
 #include "gtest/gtest.h"
 #include "utils/macro.h"
-
 #include "utils/file_system.h"
 #include "utils/date_time.h"
 #include "resumption/last_state_impl.h"
@@ -97,14 +96,15 @@ class AppLaunchDataJsonTest : public ::testing::Test {
 
   void AddApplicationDataWithIncreaseTable(const ApplicationData& data);
   void AddApplicationDataWithoutIncreaseTable(const ApplicationData& data);
-  TimevalStruct GetApplicationData_EXPECT_TRUE(const ApplicationData& in_data,
-                                               ApplicationData& out_data);
+  date_time::TimeDuration GetApplicationData_EXPECT_TRUE(
+      const ApplicationData& in_data, ApplicationData& out_data);
   void GetApplicationData_EXPECT_FALSE(const ApplicationData& in_data);
   std::string AddCounter(const std::string& inp, int32_t val);
 
   std::unique_ptr<resumption::LastState> test_last_state_;
   std::unique_ptr<AppLaunchDataJson> res_json_;
-  void SetTimestamp(const ApplicationData& in_data, TimevalStruct& timestamp);
+  void SetTimestamp(const ApplicationData& in_data,
+                    date_time::TimeDuration& timestamp);
 };
 
 void AppLaunchDataJsonTest::AddApplicationDataWithIncreaseTable(
@@ -129,7 +129,7 @@ void AppLaunchDataJsonTest::AddApplicationDataWithoutIncreaseTable(
   EXPECT_EQ(sizeBeforeAdding, sizeAfterAdding);
 }
 
-TimevalStruct AppLaunchDataJsonTest::GetApplicationData_EXPECT_TRUE(
+date_time::TimeDuration AppLaunchDataJsonTest::GetApplicationData_EXPECT_TRUE(
     const ApplicationData& in_data, ApplicationData& out_data) {
   uint32_t sizeBeforeGetting = res_json()->GetCurentNumberOfAppData();
 
@@ -148,9 +148,9 @@ TimevalStruct AppLaunchDataJsonTest::GetApplicationData_EXPECT_TRUE(
   out_data.bundle_id_ =
       json_data_list[index][am::strings::bundle_id].asString();
   // time stamp
-  TimevalStruct tmVal = {0};
-  tmVal.tv_sec =
-      json_data_list[index][am::strings::app_launch_last_session].asUInt64();
+  date_time::TimeDuration tmVal = date_time::seconds(
+      json_data_list[index][am::strings::app_launch_last_session].asUInt64());
+
   return tmVal;
 }
 
@@ -168,7 +168,7 @@ void AppLaunchDataJsonTest::GetApplicationData_EXPECT_FALSE(
 }
 
 void AppLaunchDataJsonTest::SetTimestamp(const ApplicationData& in_data,
-                                         TimevalStruct& timestamp) {
+                                         date_time::TimeDuration& timestamp) {
   uint32_t sizeBeforeGetting = res_json()->GetCurentNumberOfAppData();
 
   int32_t index = NotFound;
@@ -183,7 +183,7 @@ void AppLaunchDataJsonTest::SetTimestamp(const ApplicationData& in_data,
   EXPECT_EQ(sizeBeforeGetting, sizeAfterGetting);
   // time stamp
   json_data_list[index][am::strings::app_launch_last_session] =
-      static_cast<Json::Value::UInt64>(timestamp.tv_sec);
+      static_cast<Json::Value::UInt64>(date_time::getSecs(timestamp));
 }
 
 std::string AppLaunchDataJsonTest::AddCounter(const std::string& inp,
@@ -225,18 +225,18 @@ TEST_F(AppLaunchDataJsonTest, RefreshTimestamp) {
   ApplicationData data("mobile_app_id", "bundle_id", "device_mac");
   AddApplicationDataWithIncreaseTable(data);
   ApplicationData recoveredData("", "", "");
-  TimevalStruct timestamp1 =
+  date_time::TimeDuration timestamp1 =
       GetApplicationData_EXPECT_TRUE(data, recoveredData);
-  TimevalStruct tm = {0, 0};
+  date_time::TimeDuration tm = date_time::TimeDurationZero();
   SetTimestamp(data, tm);
-  TimevalStruct timestamp2 =
+  date_time::TimeDuration timestamp2 =
       GetApplicationData_EXPECT_TRUE(data, recoveredData);
-  EXPECT_NE(timestamp1.tv_sec, timestamp2.tv_sec);
+  EXPECT_NE(date_time::getSecs(timestamp1), date_time::getSecs(timestamp2));
   AddApplicationDataWithoutIncreaseTable(data);  // again insert the same
-  TimevalStruct timestamp3 =
+  date_time::TimeDuration timestamp3 =
       GetApplicationData_EXPECT_TRUE(data, recoveredData);
   EXPECT_TRUE(data == recoveredData);
-  EXPECT_NE(timestamp2.tv_sec, timestamp3.tv_sec);
+  EXPECT_NE(date_time::getSecs(timestamp2), date_time::getSecs(timestamp3));
 }
 
 TEST_F(AppLaunchDataJsonTest, MaxCount) {
@@ -250,7 +250,7 @@ TEST_F(AppLaunchDataJsonTest, MaxCount) {
 
   // insert new time stamp
   ApplicationData changedRecord("mobile_app_id_0", "bundle_id_0", "device_mac");
-  TimevalStruct tm = {0, 0};
+  date_time::TimeDuration tm = date_time::TimeDurationZero();
   SetTimestamp(changedRecord, tm);
 
   uint32_t size_max = res_json()->GetCurentNumberOfAppData();
diff --git a/src/components/application_manager/test/request_info_test.cc b/src/components/application_manager/test/request_info_test.cc
index 7275f9b343..0d7e6c65ac 100644
--- a/src/components/application_manager/test/request_info_test.cc
+++ b/src/components/application_manager/test/request_info_test.cc
@@ -47,10 +47,10 @@ class TestRequestInfo : public request_info::RequestInfo {
  public:
   TestRequestInfo(request_info::RequestPtr request,
                   const RequestType requst_type,
-                  const TimevalStruct& start_time,
+                  const date_time::TimeDuration& start_time,
                   const uint64_t timeout_msec)
       : RequestInfo(request, requst_type, start_time, timeout_msec) {}
-  void SetEndTime(const TimevalStruct& end_time) {
+  void SetEndTime(const date_time::TimeDuration& end_time) {
     end_time_ = end_time;
   }
 };
@@ -78,7 +78,7 @@ class RequestInfoTest : public ::testing::Test {
       uint32_t connection_key,
       uint32_t correlation_id,
       request_info::RequestInfo::RequestType requst_type,
-      const TimevalStruct& start_time,
+      const date_time::TimeDuration& start_time,
       uint64_t timeout_msec) {
     std::shared_ptr<MockRequest> mock_request =
         std::make_shared<MockRequest>(connection_key, correlation_id);
@@ -91,7 +91,7 @@ class RequestInfoTest : public ::testing::Test {
 
 TEST_F(RequestInfoTest, RequestInfoEqualEndTime) {
   std::vector<std::shared_ptr<TestRequestInfo> > requests;
-  const TimevalStruct& time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration& time = date_time::getCurrentTime();
   for (uint32_t i = 0; i < count_of_requests_for_test_; ++i) {
     std::shared_ptr<TestRequestInfo> request = CreateTestInfo(
         i, i, request_info::RequestInfo::MobileRequest, time, default_timeout_);
@@ -107,7 +107,7 @@ TEST_F(RequestInfoTest, AddRemoveHMIRequests) {
         CreateTestInfo(hmi_connection_key_,
                        i,
                        request_info::RequestInfo::HMIRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        default_timeout_);
     EXPECT_TRUE(request_info_set_.Add(request));
     EXPECT_TRUE(request_info_set_.RemoveRequest(request));
@@ -125,7 +125,7 @@ TEST_F(RequestInfoTest, AddHMIRequests_RemoveAllRequests) {
         CreateTestInfo(hmi_connection_key_,
                        i,
                        request_info::RequestInfo::HMIRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        default_timeout_);
     requests.push_back(request);
     EXPECT_TRUE(request_info_set_.Add(request));
@@ -157,14 +157,14 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequests) {
       CreateTestInfo(mobile_connection_key1_,
                      12345,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(),
+                     date_time::getCurrentTime(),
                      default_timeout_);
   EXPECT_TRUE(request_info_set_.Add(mobile_request1));
   std::shared_ptr<TestRequestInfo> mobile_request2 =
       CreateTestInfo(mobile_connection_key2_,
                      54321,
                      request_info::RequestInfo::MobileRequest,
-                     date_time::DateTime::getCurrentTime(),
+                     date_time::getCurrentTime(),
                      default_timeout_);
   EXPECT_TRUE(request_info_set_.Add(mobile_request2));
   EXPECT_EQ(2u, request_info_set_.Size());
@@ -181,7 +181,7 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequestsByConnectionKey) {
         CreateTestInfo(mobile_connection_key1_,
                        i,
                        request_info::RequestInfo::MobileRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        default_timeout_);
 
     requests.push_back(mobile_request1);
@@ -194,7 +194,7 @@ TEST_F(RequestInfoTest, AddMobileRequests_RemoveMobileRequestsByConnectionKey) {
         CreateTestInfo(mobile_connection_key2_,
                        i,
                        request_info::RequestInfo::MobileRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        default_timeout_);
 
     requests.push_back(mobile_request2);
@@ -216,7 +216,7 @@ TEST_F(RequestInfoTest, RequestInfoSetFront) {
         CreateTestInfo(mobile_connection_key1_,
                        i,
                        request_info::RequestInfo::HMIRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        i);
     request_info_set_.Add(request);
   }
@@ -250,7 +250,7 @@ TEST_F(RequestInfoTest, RequestInfoSetFind) {
         CreateTestInfo(req_it->first,
                        req_it->second,
                        request_info::RequestInfo::HMIRequest,
-                       date_time::DateTime::getCurrentTime(),
+                       date_time::getCurrentTime(),
                        10);
     EXPECT_TRUE(request_info_set_.Add(request));
   }
@@ -279,7 +279,7 @@ TEST_F(RequestInfoTest, RequestInfoSetEqualHash) {
       CreateTestInfo(connection_key,
                      corr_id,
                      request_info::RequestInfo::HMIRequest,
-                     date_time::DateTime::getCurrentTime(),
+                     date_time::getCurrentTime(),
                      10);
   EXPECT_TRUE(request_info_set.Add(request));
   EXPECT_FALSE(request_info_set.Add(request));
@@ -303,13 +303,15 @@ TEST_F(RequestInfoTest, RequestInfoSetEqualHash) {
 }
 
 TEST_F(RequestInfoTest, EndTimeisExpired) {
-  TimevalStruct time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration time = date_time::getCurrentTime();
+  // get just the seconds part of the current time
+  date_time::TimeDuration not_expired =
+      date_time::seconds(date_time::getSecs(date_time::getCurrentTime()));
+  not_expired += date_time::microseconds(std::numeric_limits<time_t>::min());
 
-  TimevalStruct not_expired = date_time::DateTime::getCurrentTime();
-  not_expired.tv_usec = std::numeric_limits<time_t>::min();
-
-  TimevalStruct expired = date_time::DateTime::getCurrentTime();
-  expired.tv_usec = std::numeric_limits<time_t>::max();
+  date_time::TimeDuration expired =
+      date_time::seconds(date_time::getSecs(date_time::getCurrentTime()));
+  expired += date_time::microseconds(std::numeric_limits<time_t>::max());
 
   std::shared_ptr<TestRequestInfo> request =
       CreateTestInfo(mobile_connection_key1_,
@@ -326,7 +328,7 @@ TEST_F(RequestInfoTest, EndTimeisExpired) {
 }
 
 TEST_F(RequestInfoTest, UpdateEndTime) {
-  TimevalStruct time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration time = date_time::getCurrentTime();
   std::shared_ptr<TestRequestInfo> request =
       CreateTestInfo(mobile_connection_key1_,
                      mobile_correlation_id,
@@ -335,12 +337,12 @@ TEST_F(RequestInfoTest, UpdateEndTime) {
                      default_timeout_);
   request->SetEndTime(time);
   request->updateEndTime();
-  TimevalStruct last_time = request->end_time();
-  EXPECT_LE(time.tv_sec, last_time.tv_sec);
+  date_time::TimeDuration last_time = request->end_time();
+  EXPECT_LE(date_time::getSecs(time), date_time::getSecs(last_time));
 }
 
 TEST_F(RequestInfoTest, UpdateTimeOut) {
-  TimevalStruct time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration time = date_time::getCurrentTime();
   std::shared_ptr<TestRequestInfo> request =
       CreateTestInfo(mobile_connection_key1_,
                      mobile_correlation_id,
@@ -351,9 +353,10 @@ TEST_F(RequestInfoTest, UpdateTimeOut) {
   request->updateEndTime();
 
   request->updateTimeOut(100);
-  time = date_time::DateTime::getCurrentTime();
-  TimevalStruct last_time = request->end_time();
-  EXPECT_NEAR(time.tv_sec + 100, last_time.tv_sec, 500);
+  time = date_time::getCurrentTime();
+  date_time::TimeDuration last_time = request->end_time();
+  EXPECT_NEAR(
+      date_time::getSecs(time) + 100, date_time::getSecs(last_time), 500);
 }
 
 }  // namespace application_manager_test
diff --git a/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h b/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h
index 1a0bfce264..cf956353dd 100644
--- a/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h
+++ b/src/components/connection_handler/include/connection_handler/heartbeat_monitor.h
@@ -102,7 +102,7 @@ class HeartBeatMonitor : public threads::ThreadDelegate {
     void RefreshExpiration();
 
     uint32_t heartbeat_timeout_mseconds_;
-    TimevalStruct heartbeat_expiration_;
+    date_time::TimeDuration heartbeat_expiration_;
     bool is_heartbeat_sent_;
   };
 
diff --git a/src/components/connection_handler/src/heartbeat_monitor.cc b/src/components/connection_handler/src/heartbeat_monitor.cc
index 50af5a042a..12994fd23a 100644
--- a/src/components/connection_handler/src/heartbeat_monitor.cc
+++ b/src/components/connection_handler/src/heartbeat_monitor.cc
@@ -163,8 +163,8 @@ HeartBeatMonitor::SessionState::SessionState(
 void HeartBeatMonitor::SessionState::RefreshExpiration() {
   LOG4CXX_DEBUG(logger_, "Refresh expiration: " << heartbeat_timeout_mseconds_);
   using namespace date_time;
-  TimevalStruct time = DateTime::getCurrentTime();
-  DateTime::AddMilliseconds(time, heartbeat_timeout_mseconds_);
+  date_time::TimeDuration time = getCurrentTime();
+  AddMilliseconds(time, heartbeat_timeout_mseconds_);
   heartbeat_expiration_ = time;
 }
 
@@ -193,8 +193,8 @@ void HeartBeatMonitor::SessionState::KeepAlive() {
 }
 
 bool HeartBeatMonitor::SessionState::HasTimeoutElapsed() {
-  TimevalStruct now = date_time::DateTime::getCurrentTime();
-  return date_time::DateTime::Greater(now, heartbeat_expiration_);
+  date_time::TimeDuration now = date_time::getCurrentTime();
+  return date_time::Greater(now, heartbeat_expiration_);
 }
 
 }  // namespace connection_handler
diff --git a/src/components/include/protocol_handler/telemetry_observer.h b/src/components/include/protocol_handler/telemetry_observer.h
index a908ebcaa1..b2bf94de35 100644
--- a/src/components/include/protocol_handler/telemetry_observer.h
+++ b/src/components/include/protocol_handler/telemetry_observer.h
@@ -45,11 +45,11 @@ class PHTelemetryObserver {
     RawMessagePtr raw_msg;
     uint32_t message_id;
     uint8_t connection_key;
-    TimevalStruct begin;
-    TimevalStruct end;
+    date_time::TimeDuration begin;
+    date_time::TimeDuration end;
   };
-  virtual void StartMessageProcess(uint32_t message_id,
-                                   const TimevalStruct& start_time) = 0;
+  virtual void StartMessageProcess(
+      uint32_t message_id, const date_time::TimeDuration& start_time) = 0;
   virtual void EndMessageProcess(std::shared_ptr<MessageMetric> m) = 0;
   virtual ~PHTelemetryObserver() {}
 };
diff --git a/src/components/include/test/protocol_handler/mock_telemetry_observer.h b/src/components/include/test/protocol_handler/mock_telemetry_observer.h
index fb1141baa4..82c42775fa 100644
--- a/src/components/include/test/protocol_handler/mock_telemetry_observer.h
+++ b/src/components/include/test/protocol_handler/mock_telemetry_observer.h
@@ -44,7 +44,8 @@ namespace protocol_handler_test {
 class MockPHTelemetryObserver : public PHTelemetryObserver {
  public:
   MOCK_METHOD2(StartMessageProcess,
-               void(uint32_t message_id, const TimevalStruct& start_time));
+               void(uint32_t message_id,
+                    const date_time::TimeDuration& start_time));
   MOCK_METHOD1(EndMessageProcess, void(std::shared_ptr<MessageMetric> m));
 };
 
diff --git a/src/components/include/utils/date_time.h b/src/components/include/utils/date_time.h
index f8f8e3d6ce..3e649cfc28 100644
--- a/src/components/include/utils/date_time.h
+++ b/src/components/include/utils/date_time.h
@@ -32,69 +32,70 @@
 #ifndef SRC_COMPONENTS_INCLUDE_UTILS_DATE_TIME_H_
 #define SRC_COMPONENTS_INCLUDE_UTILS_DATE_TIME_H_
 
-#if defined(OS_POSIX)
-#include <sys/time.h>
-typedef struct timeval TimevalStruct;
-#endif
 #include <stdint.h>
+#include "boost/date_time.hpp"
 
 namespace date_time {
 
+// skip boost namespacing for all this
+// NOTE that it's called posix_time for its functionality, not for any
+// platform-dependence
+typedef boost::posix_time::time_duration TimeDuration;
+// Capture from boost's namespaces
+using boost::posix_time::microseconds;
+using boost::posix_time::milliseconds;
+using boost::posix_time::seconds;
+
 enum TimeCompare { LESS, EQUAL, GREATER };
 
-class DateTime {
- public:
-  static const int32_t MILLISECONDS_IN_SECOND = 1000;
-  static const int32_t MICROSECONDS_IN_MILLISECOND = 1000;
-  static const int32_t NANOSECONDS_IN_MICROSECOND = 1000;
-  static const int32_t SECONDS_IN_HOUR = 3600;
-  static const int32_t MICROSECONDS_IN_SECOND =
-      MILLISECONDS_IN_SECOND * MICROSECONDS_IN_MILLISECOND;
-  static const int32_t NANOSECONDS_IN_MILLISECOND =
-      MICROSECONDS_IN_MILLISECOND * NANOSECONDS_IN_MICROSECOND;
+// public defines for external usage
+const int32_t MILLISECONDS_IN_SECOND = 1000;
+const int32_t MICROSECONDS_IN_MILLISECOND = 1000;
+const int32_t NANOSECONDS_IN_MICROSECOND = 1000;
+const int32_t SECONDS_IN_HOUR = 3600;
+const int32_t MICROSECONDS_IN_SECOND =
+    MILLISECONDS_IN_SECOND * MICROSECONDS_IN_MILLISECOND;
+const int32_t NANOSECONDS_IN_MILLISECOND =
+    MICROSECONDS_IN_MILLISECOND * NANOSECONDS_IN_MICROSECOND;
+
+TimeDuration getCurrentTime();
 
-  static TimevalStruct getCurrentTime();
+// empty duration
+TimeDuration TimeDurationZero();
 
-  // return SECONDS count
-  static int64_t getSecs(const TimevalStruct& time);
+// return SECONDS count
+int64_t getSecs(const TimeDuration& t);
 
-  // return MILLISECONDS count
-  static int64_t getmSecs(const TimevalStruct& time);
-  // return MICROSECONDS count
-  static int64_t getuSecs(const TimevalStruct& time);
+// return MILLISECONDS count
+int64_t getmSecs(const TimeDuration& t);
+// return MICROSECONDS count
+int64_t getuSecs(const TimeDuration& t);
 
-  // return MILLISECONDS count between sinceTime value and current time
-  static int64_t calculateTimeSpan(const TimevalStruct& sinceTime);
+// get just the MILLISECONDS count (< 1000)
+int64_t get_just_mSecs(const TimeDuration& t);
 
-  // return MILLISECONDS count between time1 and time2
-  static int64_t calculateTimeDiff(const TimevalStruct& time1,
-                                   const TimevalStruct& time2);
+// get just the MICROSECONDS count (< 1000)
+int64_t get_just_uSecs(const TimeDuration& t);
 
-  /**
-   * @brief Adds milliseconds to time struct
-   * @param time contains time struct
-   * @param milliseconds contains value which need to
-   * add to time struct
-   **/
-  static void AddMilliseconds(TimevalStruct& time, uint32_t milliseconds);
+// return MILLISECONDS count between sinceTime value and current time
+int64_t calculateTimeSpan(const TimeDuration& sinceTime);
 
-  static TimevalStruct Sub(const TimevalStruct& time1,
-                           const TimevalStruct& time2);
+// return MILLISECONDS count between time1 and time2
+int64_t calculateTimeDiff(const TimeDuration& time1, const TimeDuration& time2);
 
-  static TimeCompare compareTime(const TimevalStruct& time1,
-                                 const TimevalStruct& time2);
+/**
+ * @brief Adds milliseconds to time struct
+ * @param time contains time struct
+ * @param milliseconds contains value which need to
+ * add to time struct
+ **/
+void AddMilliseconds(TimeDuration& time, uint32_t milliseconds);
 
-  static bool Greater(const TimevalStruct& time1, const TimevalStruct& time2);
-  static bool Less(const TimevalStruct& time1, const TimevalStruct& time2);
-  static bool Equal(const TimevalStruct& time1, const TimevalStruct& time2);
+TimeCompare compareTime(const TimeDuration& time1, const TimeDuration& time2);
 
- private:
-  static TimevalStruct ConvertionUsecs(const TimevalStruct& time);
-};
+bool Greater(const TimeDuration& time1, const TimeDuration& time2);
+bool Less(const TimeDuration& time1, const TimeDuration& time2);
+bool Equal(const TimeDuration& time1, const TimeDuration& time2);
 
 }  // namespace date_time
-bool operator<(const TimevalStruct& time1, const TimevalStruct& time2);
-bool operator==(const TimevalStruct& time1, const TimevalStruct& time2);
-const TimevalStruct operator-(const TimevalStruct& time1,
-                              const TimevalStruct& time2);
 #endif  // SRC_COMPONENTS_INCLUDE_UTILS_DATE_TIME_H_
diff --git a/src/components/include/utils/messagemeter.h b/src/components/include/utils/messagemeter.h
index 42b658ad6b..1148a65b57 100644
--- a/src/components/include/utils/messagemeter.h
+++ b/src/components/include/utils/messagemeter.h
@@ -34,8 +34,8 @@
 #define SRC_COMPONENTS_INCLUDE_UTILS_MESSAGEMETER_H_
 
 #include <cstddef>
-#include <set>
 #include <map>
+#include <set>
 #include "utils/date_time.h"
 
 namespace utils {
@@ -82,20 +82,19 @@ class MessageMeter {
   void ClearIdentifiers();
 
   void set_time_range(const size_t time_range_msecs);
-  void set_time_range(const TimevalStruct& time_range);
-  TimevalStruct time_range() const;
+  void set_time_range(const date_time::TimeDuration& time_range);
+  date_time::TimeDuration time_range() const;
 
  private:
-  TimevalStruct time_range_;
-  typedef std::multiset<TimevalStruct> Timings;
+  date_time::TimeDuration time_range_;
+  typedef std::multiset<date_time::TimeDuration> Timings;
   typedef std::map<Id, Timings> TimingMap;
   TimingMap timing_map_;
 };
 
 template <class Id>
-MessageMeter<Id>::MessageMeter()
-    : time_range_(TimevalStruct{0, 0}) {
-  time_range_.tv_sec = 1;
+MessageMeter<Id>::MessageMeter() {
+  time_range_ = date_time::seconds(1);
 }
 
 template <class Id>
@@ -106,7 +105,7 @@ size_t MessageMeter<Id>::TrackMessage(const Id& id) {
 template <class Id>
 size_t MessageMeter<Id>::TrackMessages(const Id& id, const size_t count) {
   Timings& timings = timing_map_[id];
-  const TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration current_time = date_time::getCurrentTime();
   for (size_t i = 0; i < count; ++i) {
     // Adding to the end is amortized constant
     timings.insert(timings.end(), current_time);
@@ -124,8 +123,8 @@ size_t MessageMeter<Id>::Frequency(const Id& id) {
   if (timings.empty()) {
     return 0u;
   }
-  const TimevalStruct actual_begin_time = date_time::DateTime::Sub(
-      date_time::DateTime::getCurrentTime(), time_range_);
+  const date_time::TimeDuration actual_begin_time =
+      (date_time::getCurrentTime() - time_range_);
   timings.erase(timings.begin(), timings.upper_bound(actual_begin_time));
   return timings.size();
 }
@@ -142,21 +141,15 @@ void MessageMeter<Id>::ClearIdentifiers() {
 
 template <class Id>
 void MessageMeter<Id>::set_time_range(const size_t time_range_msecs) {
-  // TODO(EZamakhov): move to date_time::DateTime
-  const size_t secs =
-      time_range_msecs / date_time::DateTime::MILLISECONDS_IN_SECOND;
-  time_range_.tv_sec = secs;
-  const size_t mSecs =
-      time_range_msecs % date_time::DateTime::MILLISECONDS_IN_SECOND;
-  time_range_.tv_usec =
-      mSecs * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  time_range_ = date_time::milliseconds(time_range_msecs);
 }
 template <class Id>
-void MessageMeter<Id>::set_time_range(const TimevalStruct& time_range) {
+void MessageMeter<Id>::set_time_range(
+    const date_time::TimeDuration& time_range) {
   time_range_ = time_range;
 }
 template <class Id>
-TimevalStruct MessageMeter<Id>::time_range() const {
+date_time::TimeDuration MessageMeter<Id>::time_range() const {
   return time_range_;
 }
 }  // namespace utils
diff --git a/src/components/policy/policy_external/src/cache_manager.cc b/src/components/policy/policy_external/src/cache_manager.cc
index 5387a7700a..e4a4151fa4 100644
--- a/src/components/policy/policy_external/src/cache_manager.cc
+++ b/src/components/policy/policy_external/src/cache_manager.cc
@@ -1117,8 +1117,8 @@ bool CacheManager::SetUserPermissionsForApp(
           it_group->second != is_allowed) {
         *out_app_permissions_changed = true;
 
-        const TimevalStruct tm = date_time::DateTime::getCurrentTime();
-        int64_t current_time_msec = date_time::DateTime::getmSecs(tm);
+        const date_time::TimeDuration tm = date_time::getCurrentTime();
+        int64_t current_time_msec = date_time::getmSecs(tm);
         ucr.consent_last_updated = current_time_msec;
         LOG4CXX_DEBUG(logger_, "Updating consents time " << current_time_msec);
       }
@@ -1331,7 +1331,7 @@ int CacheManager::TimeoutResponse() {
   CACHE_MANAGER_CHECK(0);
   sync_primitives::AutoLock auto_lock(cache_lock_);
   return pt_->policy_table.module_config.timeout_after_x_seconds *
-         date_time::DateTime::MILLISECONDS_IN_SECOND;
+         date_time::MILLISECONDS_IN_SECOND;
 }
 
 bool CacheManager::SecondsBetweenRetries(std::vector<int>& seconds) {
@@ -2651,8 +2651,8 @@ void CacheManager::SetExternalConsentForApp(
       (*(*pt_->policy_table.device_data)[permissions.device_id]
             .user_consent_records)[permissions.policy_app_id];
 
-  const TimevalStruct tm = date_time::DateTime::getCurrentTime();
-  int64_t current_time_msec = date_time::DateTime::getmSecs(tm);
+  const date_time::TimeDuration tm = date_time::getCurrentTime();
+  int64_t current_time_msec = date_time::getmSecs(tm);
   app_consent_records.ext_consent_last_updated = current_time_msec;
   LOG4CXX_DEBUG(logger_, "Updating consents time " << current_time_msec);
 
diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc
index 5f651645d9..c7d814e56e 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -1496,7 +1496,7 @@ void PolicyManagerImpl::CalculateGroupsConsentFromExternalConsent(
 bool PolicyManagerImpl::ExceededDays() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
   const int kSecondsInDay = 60 * 60 * 24;
   const int days = current_time.tv_sec / kSecondsInDay;
 
diff --git a/src/components/policy/policy_external/src/sql_pt_representation.cc b/src/components/policy/policy_external/src/sql_pt_representation.cc
index b9b0194199..6b07cc647f 100644
--- a/src/components/policy/policy_external/src/sql_pt_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_representation.cc
@@ -235,10 +235,10 @@ int SQLPTRepresentation::TimeoutResponse() {
   utils::dbms::SQLQuery query(db());
   if (!query.Prepare(sql_pt::kSelectTimeoutResponse) || !query.Exec()) {
     LOG4CXX_INFO(logger_, "Can not select timeout response for retry sequence");
-    const int defaultTimeout = 30 * date_time::DateTime::MILLISECONDS_IN_SECOND;
+    const int defaultTimeout = 30 * date_time::MILLISECONDS_IN_SECOND;
     return defaultTimeout;
   }
-  return query.GetInteger(0) * date_time::DateTime::MILLISECONDS_IN_SECOND;
+  return query.GetInteger(0) * date_time::MILLISECONDS_IN_SECOND;
 }
 
 bool SQLPTRepresentation::SecondsBetweenRetries(std::vector<int>* seconds) {
diff --git a/src/components/policy/policy_external/src/usage_statistics/counter.cc b/src/components/policy/policy_external/src/usage_statistics/counter.cc
index a7e8368239..d46f6a315a 100644
--- a/src/components/policy/policy_external/src/usage_statistics/counter.cc
+++ b/src/components/policy/policy_external/src/usage_statistics/counter.cc
@@ -107,8 +107,7 @@ AppStopwatchImpl::~AppStopwatchImpl() {}
 
 void AppStopwatchImpl::Start(AppStopwatchId stopwatch_type) {
   stopwatch_type_ = stopwatch_type;
-  timer_.Start(time_out_ * date_time::DateTime::MILLISECONDS_IN_SECOND,
-               timer::kPeriodic);
+  timer_.Start(time_out_ * date_time::MILLISECONDS_IN_SECOND, timer::kPeriodic);
 }
 
 void AppStopwatchImpl::Switch(AppStopwatchId stopwatch_type) {
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
index 4ef6ed3e10..8d2802c831 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_ptu_test.cc
@@ -924,7 +924,7 @@ TEST_F(
 }
 
 uint32_t GetCurrentDaysCount() {
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
   const uint32_t kSecondsInDay = 60 * 60 * 24;
   return current_time.tv_sec / kSecondsInDay;
 }
diff --git a/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc b/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
index 404991c969..4df4012ad3 100644
--- a/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
+++ b/src/components/policy/policy_external/test/policy_manager_impl_user_consent_test.cc
@@ -69,7 +69,7 @@ TEST_F(
   // To set UP_TO_DATE before registration
   GetPTU(kValidSdlPtUpdateJson);
 
-  const TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration current_time = date_time::getCurrentTime();
   const int kSecondsInDay = 60 * 60 * 24;
   const int days_after_epoch = current_time.tv_sec / kSecondsInDay;
 
diff --git a/src/components/policy/policy_regular/src/cache_manager.cc b/src/components/policy/policy_regular/src/cache_manager.cc
index 092fd5b9a4..9accabf59b 100644
--- a/src/components/policy/policy_regular/src/cache_manager.cc
+++ b/src/components/policy/policy_regular/src/cache_manager.cc
@@ -645,7 +645,7 @@ int CacheManager::TimeoutResponse() {
   CACHE_MANAGER_CHECK(0);
   sync_primitives::AutoLock auto_lock(cache_lock_);
   return pt_->policy_table.module_config.timeout_after_x_seconds *
-         date_time::DateTime::MILLISECONDS_IN_SECOND;
+         date_time::MILLISECONDS_IN_SECOND;
 }
 
 bool CacheManager::SecondsBetweenRetries(std::vector<int>& seconds) {
diff --git a/src/components/policy/policy_regular/src/policy_manager_impl.cc b/src/components/policy/policy_regular/src/policy_manager_impl.cc
index ebc695142e..f4b6f0ae03 100644
--- a/src/components/policy/policy_regular/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_regular/src/policy_manager_impl.cc
@@ -62,7 +62,7 @@ void DeleteManager(policy::PolicyManager* pm) {
 
 namespace {
 const uint32_t kDefaultRetryTimeoutInMSec =
-    60u * date_time::DateTime::MILLISECONDS_IN_SECOND;
+    60u * date_time::MILLISECONDS_IN_SECOND;
 }  // namespace
 
 namespace policy {
@@ -827,9 +827,9 @@ const PolicySettings& PolicyManagerImpl::get_settings() const {
 bool PolicyManagerImpl::ExceededDays() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
   const int kSecondsInDay = 60 * 60 * 24;
-  const int days = current_time.tv_sec / kSecondsInDay;
+  const int days = date_time::getSecs(current_time) / kSecondsInDay;
 
   return 0 == cache_->DaysBeforeExchange(days);
 }
@@ -879,8 +879,7 @@ uint32_t PolicyManagerImpl::NextRetryTimeout() {
   }
 
   for (uint32_t i = 0u; i < retry_sequence_index_; ++i) {
-    next += retry_sequence_seconds_[i] *
-            date_time::DateTime::MILLISECONDS_IN_SECOND;
+    next += retry_sequence_seconds_[i] * date_time::MILLISECONDS_IN_SECOND;
     next += retry_sequence_timeout_;
   }
   ++retry_sequence_index_;
diff --git a/src/components/policy/policy_regular/src/sql_pt_representation.cc b/src/components/policy/policy_regular/src/sql_pt_representation.cc
index 00f3349050..8efe2fb59e 100644
--- a/src/components/policy/policy_regular/src/sql_pt_representation.cc
+++ b/src/components/policy/policy_regular/src/sql_pt_representation.cc
@@ -187,10 +187,10 @@ int SQLPTRepresentation::TimeoutResponse() {
   utils::dbms::SQLQuery query(db());
   if (!query.Prepare(sql_pt::kSelectTimeoutResponse) || !query.Exec()) {
     LOG4CXX_INFO(logger_, "Can not select timeout response for retry sequence");
-    const int defaultTimeout = 30 * date_time::DateTime::MILLISECONDS_IN_SECOND;
+    const int defaultTimeout = 30 * date_time::MILLISECONDS_IN_SECOND;
     return defaultTimeout;
   }
-  return query.GetInteger(0) * date_time::DateTime::MILLISECONDS_IN_SECOND;
+  return query.GetInteger(0) * date_time::MILLISECONDS_IN_SECOND;
 }
 
 bool SQLPTRepresentation::SecondsBetweenRetries(std::vector<int>* seconds) {
diff --git a/src/components/policy/policy_regular/src/usage_statistics/counter.cc b/src/components/policy/policy_regular/src/usage_statistics/counter.cc
index 199b5ae779..ed16fa3e8d 100644
--- a/src/components/policy/policy_regular/src/usage_statistics/counter.cc
+++ b/src/components/policy/policy_regular/src/usage_statistics/counter.cc
@@ -103,8 +103,7 @@ AppStopwatchImpl::AppStopwatchImpl(
 
 void AppStopwatchImpl::Start(AppStopwatchId stopwatch_type) {
   stopwatch_type_ = stopwatch_type;
-  timer_.Start(time_out_ * date_time::DateTime::MILLISECONDS_IN_SECOND,
-               timer::kPeriodic);
+  timer_.Start(time_out_ * date_time::MILLISECONDS_IN_SECOND, timer::kPeriodic);
 }
 
 void AppStopwatchImpl::Switch(AppStopwatchId stopwatch_type) {
diff --git a/src/components/policy/policy_regular/test/policy_manager_impl_test.cc b/src/components/policy/policy_regular/test/policy_manager_impl_test.cc
index 9b38bc3be8..9f73f60d28 100644
--- a/src/components/policy/policy_regular/test/policy_manager_impl_test.cc
+++ b/src/components/policy/policy_regular/test/policy_manager_impl_test.cc
@@ -838,9 +838,9 @@ TEST_F(PolicyManagerImplTest2,
        PTUpdatedAt_DaysNotExceedLimit_ExpectNoUpdateRequired) {
   // Arrange
   CreateLocalPT("sdl_preloaded_pt.json");
-  TimevalStruct current_time = date_time::DateTime::getCurrentTime();
+  date_time::TimeDuration current_time = date_time::getCurrentTime();
   const int kSecondsInDay = 60 * 60 * 24;
-  int days = current_time.tv_sec / kSecondsInDay;
+  int days = date_time::getSecs(current_time) / kSecondsInDay;
   EXPECT_EQ("UP_TO_DATE", manager->GetPolicyTableStatus());
 
   GetPTU("valid_sdl_pt_update.json");
@@ -898,24 +898,24 @@ TEST_F(PolicyManagerImplTest2, NextRetryTimeout_ExpectTimeoutsFromPT) {
     uint32_t timeout_after_x_seconds =
         root["policy_table"]["module_config"]["timeout_after_x_seconds"]
             .asInt() *
-        date_time::DateTime::MILLISECONDS_IN_SECOND;
+        date_time::MILLISECONDS_IN_SECOND;
     const uint32_t first_retry = timeout_after_x_seconds;
     EXPECT_EQ(first_retry, manager->NextRetryTimeout());
-    uint32_t next_retry = first_retry +
-                          seconds_between_retries[0].asInt() *
-                              date_time::DateTime::MILLISECONDS_IN_SECOND;
+    uint32_t next_retry =
+        first_retry +
+        seconds_between_retries[0].asInt() * date_time::MILLISECONDS_IN_SECOND;
     EXPECT_EQ(next_retry, manager->NextRetryTimeout());
-    next_retry = first_retry + next_retry +
-                 seconds_between_retries[1].asInt() *
-                     date_time::DateTime::MILLISECONDS_IN_SECOND;
+    next_retry =
+        first_retry + next_retry +
+        seconds_between_retries[1].asInt() * date_time::MILLISECONDS_IN_SECOND;
     EXPECT_EQ(next_retry, manager->NextRetryTimeout());
-    next_retry = first_retry + next_retry +
-                 seconds_between_retries[2].asInt() *
-                     date_time::DateTime::MILLISECONDS_IN_SECOND;
+    next_retry =
+        first_retry + next_retry +
+        seconds_between_retries[2].asInt() * date_time::MILLISECONDS_IN_SECOND;
     EXPECT_EQ(next_retry, manager->NextRetryTimeout());
-    next_retry = first_retry + next_retry +
-                 seconds_between_retries[3].asInt() *
-                     date_time::DateTime::MILLISECONDS_IN_SECOND;
+    next_retry =
+        first_retry + next_retry +
+        seconds_between_retries[3].asInt() * date_time::MILLISECONDS_IN_SECOND;
     EXPECT_EQ(next_retry, manager->NextRetryTimeout());
   }
 }
diff --git a/src/components/protocol_handler/include/protocol_handler/multiframe_builder.h b/src/components/protocol_handler/include/protocol_handler/multiframe_builder.h
index bac37b508c..84ec3c9e30 100644
--- a/src/components/protocol_handler/include/protocol_handler/multiframe_builder.h
+++ b/src/components/protocol_handler/include/protocol_handler/multiframe_builder.h
@@ -60,7 +60,7 @@ typedef uint32_t MessageID;
 
 struct ProtocolFrameData {
   ProtocolFramePtr frame;
-  TimevalStruct append_time;
+  date_time::TimeDuration append_time;
 };
 /**
  *\brief Map of frames with last frame data for messages received in multiple
diff --git a/src/components/protocol_handler/src/multiframe_builder.cc b/src/components/protocol_handler/src/multiframe_builder.cc
index 5afae51292..c34e2ec640 100644
--- a/src/components/protocol_handler/src/multiframe_builder.cc
+++ b/src/components/protocol_handler/src/multiframe_builder.cc
@@ -124,7 +124,7 @@ ProtocolFramePtrList MultiFrameBuilder::PopMultiframes() {
         if (consecutive_frame_wait_msecs_ != 0) {
           LOG4CXX_TRACE(logger_, "Expiration verification");
           const int64_t time_left =
-              date_time::DateTime::calculateTimeSpan(frame_data.append_time);
+              date_time::calculateTimeSpan(frame_data.append_time);
           LOG4CXX_DEBUG(logger_, "mSecs left: " << time_left);
           if (time_left >= consecutive_frame_wait_msecs_) {
             LOG4CXX_WARN(logger_, "Expired frame: " << frame);
@@ -200,7 +200,7 @@ RESULT_CODE MultiFrameBuilder::HandleFirstFrame(const ProtocolFramePtr packet) {
                     << connection_id
                     << ", session_id: " << static_cast<int>(session_id)
                     << ", message_id: " << message_id);
-  messageId_map[message_id] = {packet, date_time::DateTime::getCurrentTime()};
+  messageId_map[message_id] = {packet, date_time::getCurrentTime()};
   return RESULT_OK;
 }
 
@@ -279,7 +279,7 @@ RESULT_CODE MultiFrameBuilder::HandleConsecutiveFrame(
   LOG4CXX_INFO(logger_,
                "Assembled frame with payload size: "
                    << assembling_frame->payload_size());
-  frame_data.append_time = date_time::DateTime::getCurrentTime();
+  frame_data.append_time = date_time::getCurrentTime();
   return RESULT_OK;
 }
 
diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc
index b595c977aa..093d89490b 100644
--- a/src/components/protocol_handler/src/protocol_handler_impl.cc
+++ b/src/components/protocol_handler/src/protocol_handler_impl.cc
@@ -838,7 +838,7 @@ void ProtocolHandlerImpl::SendHeartBeat(int32_t connection_id,
 void ProtocolHandlerImpl::SendMessageToMobileApp(const RawMessagePtr message,
                                                  bool final_message) {
 #ifdef TELEMETRY_MONITOR
-  const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration start_time = date_time::getCurrentTime();
 #endif  // TELEMETRY_MONITOR
   LOG4CXX_AUTO_TRACE(logger_);
   if (!message) {
@@ -983,7 +983,7 @@ void ProtocolHandlerImpl::OnTMMessageReceived(const RawMessagePtr tm_message) {
        it != protocol_frames.end();
        ++it) {
 #ifdef TELEMETRY_MONITOR
-    const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+    const date_time::TimeDuration start_time = date_time::getCurrentTime();
 #endif  // TELEMETRY_MONITOR
     ProtocolFramePtr frame = *it;
 #ifdef ENABLE_SECURITY
diff --git a/src/components/protocol_handler/test/include/protocol_handler/mock_telemetry_observer.h b/src/components/protocol_handler/test/include/protocol_handler/mock_telemetry_observer.h
index f42a0b4a15..9a91a5d1f7 100644
--- a/src/components/protocol_handler/test/include/protocol_handler/mock_telemetry_observer.h
+++ b/src/components/protocol_handler/test/include/protocol_handler/mock_telemetry_observer.h
@@ -35,6 +35,7 @@
 
 #include "gmock/gmock.h"
 #include "protocol_handler/time_metric_observer.h"
+#include "utils/shared_ptr.h"
 
 namespace test {
 namespace components {
@@ -42,7 +43,8 @@ namespace protocol_handler_test {
 
 class MockPHTelemetryObserver : public ::protocol_handler::PHTelemetryObserver {
  public:
-  MOCK_METHOD2(StartMessageProcess, void(uint32_t, const TimevalStruct&));
+  MOCK_METHOD2(StartMessageProcess,
+               void(uint32_t, const date_time::TimeDuration&));
   MOCK_METHOD2(EndMessageProcess, void(std::shared_ptr<MessageMetric>));
 };
 
diff --git a/src/components/security_manager/src/crypto_manager_impl.cc b/src/components/security_manager/src/crypto_manager_impl.cc
index 1dabb00bcd..90ae0177ec 100644
--- a/src/components/security_manager/src/crypto_manager_impl.cc
+++ b/src/components/security_manager/src/crypto_manager_impl.cc
@@ -354,8 +354,8 @@ bool CryptoManagerImpl::IsCertificateUpdateRequired(
     return true;
   }
 
-  return seconds <= (get_settings().update_before_hours() *
-                     date_time::DateTime::SECONDS_IN_HOUR);
+  return seconds <=
+         (get_settings().update_before_hours() * date_time::SECONDS_IN_HOUR);
 }
 
 const CryptoManagerSettings& CryptoManagerImpl::get_settings() const {
diff --git a/src/components/telemetry_monitor/include/telemetry_monitor/protocol_handler_observer.h b/src/components/telemetry_monitor/include/telemetry_monitor/protocol_handler_observer.h
index fabf8042d0..27a4fda868 100644
--- a/src/components/telemetry_monitor/include/telemetry_monitor/protocol_handler_observer.h
+++ b/src/components/telemetry_monitor/include/telemetry_monitor/protocol_handler_observer.h
@@ -45,13 +45,13 @@ class ProtocolHandlerObserver : public protocol_handler::PHTelemetryObserver {
   explicit ProtocolHandlerObserver(TelemetryMonitor* telemetry_monitor);
 
   virtual void StartMessageProcess(uint32_t message_id,
-                                   const TimevalStruct& start_time);
+                                   const date_time::TimeDuration& start_time);
 
   virtual void EndMessageProcess(std::shared_ptr<MessageMetric> m);
 
  private:
   TelemetryMonitor* telemetry_monitor_;
-  std::map<uint32_t, TimevalStruct> time_starts;
+  std::map<uint32_t, date_time::TimeDuration> time_starts;
 };
 }  // namespace telemetry_monitor
 #endif  // SRC_COMPONENTS_TELEMETRY_MONITOR_INCLUDE_TELEMETRY_MONITOR_PROTOCOL_HANDLER_OBSERVER_H_
diff --git a/src/components/telemetry_monitor/include/telemetry_monitor/transport_manager_observer.h b/src/components/telemetry_monitor/include/telemetry_monitor/transport_manager_observer.h
index bff5834586..d0bf4ba5bb 100644
--- a/src/components/telemetry_monitor/include/telemetry_monitor/transport_manager_observer.h
+++ b/src/components/telemetry_monitor/include/telemetry_monitor/transport_manager_observer.h
@@ -49,7 +49,8 @@ class TransportManagerObserver : public transport_manager::TMTelemetryObserver {
 
  private:
   TelemetryMonitor* telemetry_monitor_;
-  std::map<const protocol_handler::RawMessage*, TimevalStruct> time_starts;
+  std::map<const protocol_handler::RawMessage*, date_time::TimeDuration>
+      time_starts;
 };
 }  // namespace telemetry_monitor
 #endif  // SRC_COMPONENTS_TELEMETRY_MONITOR_INCLUDE_TELEMETRY_MONITOR_TRANSPORT_MANAGER_OBSERVER_H_
diff --git a/src/components/telemetry_monitor/src/application_manager_metric_wrapper.cc b/src/components/telemetry_monitor/src/application_manager_metric_wrapper.cc
index b693d9df22..2dabc210f7 100644
--- a/src/components/telemetry_monitor/src/application_manager_metric_wrapper.cc
+++ b/src/components/telemetry_monitor/src/application_manager_metric_wrapper.cc
@@ -41,9 +41,8 @@ Json::Value ApplicationManagerMetricWrapper::GetJsonMetric() {
   Json::Value result = MetricWrapper::GetJsonMetric();
   result[strings::logger] = "ApplicationManager";
   result[strings::begin] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->begin));
-  result[strings::end] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->end));
+      Json::Int64(date_time::getuSecs(message_metric->begin));
+  result[strings::end] = Json::Int64(date_time::getuSecs(message_metric->end));
   const NsSmartDeviceLink::NsSmartObjects::SmartObject& params =
       message_metric->message->getElement(application_manager::strings::params);
   result[strings::correlation_id] = utils::ConvertInt64ToLongLongInt(
diff --git a/src/components/telemetry_monitor/src/protocol_handler_metric_wrapper.cc b/src/components/telemetry_monitor/src/protocol_handler_metric_wrapper.cc
index 335f0dbb29..1591e00af8 100644
--- a/src/components/telemetry_monitor/src/protocol_handler_metric_wrapper.cc
+++ b/src/components/telemetry_monitor/src/protocol_handler_metric_wrapper.cc
@@ -40,9 +40,8 @@ Json::Value ProtocolHandlerMecticWrapper::GetJsonMetric() {
   Json::Value result = MetricWrapper::GetJsonMetric();
   result[strings::logger] = "ProtocolHandler";
   result[strings::begin] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->begin));
-  result[strings::end] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->end));
+      Json::Int64(date_time::getuSecs(message_metric->begin));
+  result[strings::end] = Json::Int64(date_time::getuSecs(message_metric->end));
   result[strings::message_id] = message_metric->message_id;
   result[strings::connection_key] = message_metric->connection_key;
   return result;
diff --git a/src/components/telemetry_monitor/src/protocol_handler_observer.cc b/src/components/telemetry_monitor/src/protocol_handler_observer.cc
index 95f1a87b67..19b04da392 100644
--- a/src/components/telemetry_monitor/src/protocol_handler_observer.cc
+++ b/src/components/telemetry_monitor/src/protocol_handler_observer.cc
@@ -44,7 +44,7 @@ ProtocolHandlerObserver::ProtocolHandlerObserver(
     : telemetry_monitor_(telemetry_monitor) {}
 
 void ProtocolHandlerObserver::StartMessageProcess(
-    uint32_t message_id, const TimevalStruct& start_time) {
+    uint32_t message_id, const date_time::TimeDuration& start_time) {
   if (message_id == 0) {
     return;
   }
@@ -60,14 +60,14 @@ void ProtocolHandlerObserver::StartMessageProcess(
 void ProtocolHandlerObserver::EndMessageProcess(
     std::shared_ptr<MessageMetric> m) {
   uint32_t message_id = m->message_id;
-  std::map<uint32_t, TimevalStruct>::const_iterator it =
+  std::map<uint32_t, date_time::TimeDuration>::const_iterator it =
       time_starts.find(message_id);
   if (it == time_starts.end()) {
     LOG4CXX_WARN(logger_, "Cant find start time for message" << message_id);
     return;
   }
   m->begin = time_starts[message_id];
-  m->end = date_time::DateTime::getCurrentTime();
+  m->end = date_time::getCurrentTime();
   auto metric = std::make_shared<ProtocolHandlerMecticWrapper>();
   metric->message_metric = m;
   metric->grabResources();
diff --git a/src/components/telemetry_monitor/src/telemetry_monitor.cc b/src/components/telemetry_monitor/src/telemetry_monitor.cc
index c101672bbd..d62724a479 100644
--- a/src/components/telemetry_monitor/src/telemetry_monitor.cc
+++ b/src/components/telemetry_monitor/src/telemetry_monitor.cc
@@ -1,34 +1,34 @@
 /*
-* Copyright (c) 2014, Ford Motor Company
-* All rights reserved.
-*
-* Redistribution and use in source and binary forms, with or without
-* modification, are permitted provided that the following conditions are met:
-*
-* Redistributions of source code must retain the above copyright notice, this
-* list of conditions and the following disclaimer.
-*
-* Redistributions in binary form must reproduce the above copyright notice,
-* this list of conditions and the following
-* disclaimer in the documentation and/or other materials provided with the
-* distribution.
-*
-* Neither the name of the Ford Motor Company nor the names of its contributors
-* may be used to endorse or promote products derived from this software
-* without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-* POSSIBILITY OF SUCH DAMAGE.
-*/
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
 
 #include "telemetry_monitor/telemetry_monitor.h"
 
@@ -248,8 +248,9 @@ bool Streamer::IsReady() const {
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(client_socket_fd_, &fds);
-  TimevalStruct tv = {0, 0};
-  tv.tv_sec = 5;  // set a 5 second timeout
+  // need to construct a timeval for the duration, can't use duration
+  struct timeval tv;
+  tv.tv_sec = 5;
   tv.tv_usec = 0;
 
   const int retval = select(client_socket_fd_ + 1, 0, &fds, 0, &tv);
diff --git a/src/components/telemetry_monitor/src/transport_manager_metric_wrapper.cc b/src/components/telemetry_monitor/src/transport_manager_metric_wrapper.cc
index a891aa1118..789da92eaf 100644
--- a/src/components/telemetry_monitor/src/transport_manager_metric_wrapper.cc
+++ b/src/components/telemetry_monitor/src/transport_manager_metric_wrapper.cc
@@ -41,9 +41,8 @@ Json::Value TransportManagerMecticWrapper::GetJsonMetric() {
   Json::Value result = MetricWrapper::GetJsonMetric();
   result[strings::logger] = "TransportManager";
   result[strings::begin] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->begin));
-  result[strings::end] =
-      Json::Int64(date_time::DateTime::getuSecs(message_metric->end));
+      Json::Int64(date_time::getuSecs(message_metric->begin));
+  result[strings::end] = Json::Int64(date_time::getuSecs(message_metric->end));
   result[strings::data_size] = static_cast<uint32_t>(message_metric->data_size);
   return result;
 }
diff --git a/src/components/telemetry_monitor/src/transport_manager_observer.cc b/src/components/telemetry_monitor/src/transport_manager_observer.cc
index fc598844a4..25817d6c73 100644
--- a/src/components/telemetry_monitor/src/transport_manager_observer.cc
+++ b/src/components/telemetry_monitor/src/transport_manager_observer.cc
@@ -44,20 +44,20 @@ TransportManagerObserver::TransportManagerObserver(
 
 void TransportManagerObserver::StartRawMsg(
     const protocol_handler::RawMessage* ptr) {
-  time_starts[ptr] = date_time::DateTime::getCurrentTime();
+  time_starts[ptr] = date_time::getCurrentTime();
 }
 
 void TransportManagerObserver::StopRawMsg(
     const protocol_handler::RawMessage* ptr) {
-  std::map<const protocol_handler::RawMessage*, TimevalStruct>::const_iterator
-      it;
+  std::map<const protocol_handler::RawMessage*,
+           date_time::TimeDuration>::const_iterator it;
   it = time_starts.find(ptr);
   if (it != time_starts.end()) {
     auto m = std::make_shared<TransportManagerMecticWrapper>();
     m->message_metric = std::make_shared<
         transport_manager::TMTelemetryObserver::MessageMetric>();
     m->message_metric->begin = it->second;
-    m->message_metric->end = date_time::DateTime::getCurrentTime();
+    m->message_metric->end = date_time::getCurrentTime();
     m->message_metric->data_size = ptr->data_size();
     m->grabResources();
     telemetry_monitor_->SendMetric(m);
diff --git a/src/components/telemetry_monitor/test/application_manager_metric_test.cc b/src/components/telemetry_monitor/test/application_manager_metric_test.cc
index c3f0c26cde..01eb915326 100644
--- a/src/components/telemetry_monitor/test/application_manager_metric_test.cc
+++ b/src/components/telemetry_monitor/test/application_manager_metric_test.cc
@@ -50,13 +50,10 @@ TEST(ApplicationManagerMetricWrapper, grabResources) {
 TEST(ApplicationManagerMetricWrapper, GetJsonMetric) {
   ApplicationManagerMetricWrapper metric_test;
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
+
+  date_time::TimeDuration end_time = date_time::seconds(10);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
   metric_test.message_metric = std::make_shared<
       application_manager::AMTelemetryObserver::MessageMetric>();
   metric_test.message_metric->begin = start_time;
@@ -75,9 +72,9 @@ TEST(ApplicationManagerMetricWrapper, GetJsonMetric) {
   EXPECT_EQ("null\n",
             jvalue[telemetry_monitor::strings::memory].toStyledString());
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
+  EXPECT_EQ(date_time::getuSecs(start_time),
             jvalue[telemetry_monitor::strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
+  EXPECT_EQ(date_time::getuSecs(end_time),
             jvalue[telemetry_monitor::strings::end].asInt64());
   EXPECT_EQ(obj["params"][application_manager::strings::correlation_id].asInt(),
             jvalue[telemetry_monitor::strings::correlation_id].asInt64());
@@ -90,13 +87,9 @@ TEST(ApplicationManagerMetricWrapper, GetJsonMetricWithGrabResources) {
   utils::ResourseUsage* resources = utils::Resources::getCurrentResourseUsage();
   EXPECT_TRUE(metric_test.grabResources());
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
+  date_time::TimeDuration end_time = date_time::seconds(10);
 
   metric_test.message_metric = std::make_shared<
       application_manager::AMTelemetryObserver::MessageMetric>();
@@ -109,18 +102,18 @@ TEST(ApplicationManagerMetricWrapper, GetJsonMetricWithGrabResources) {
       std::make_shared<NsSmartDeviceLink::NsSmartObjects::SmartObject>(obj);
   Json::Value jvalue = metric_test.GetJsonMetric();
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
+  EXPECT_EQ(date_time::getuSecs(start_time),
             jvalue[telemetry_monitor::strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
+  EXPECT_EQ(date_time::getuSecs(end_time),
             jvalue[telemetry_monitor::strings::end].asInt64());
   EXPECT_EQ(obj["params"][application_manager::strings::correlation_id].asInt(),
             jvalue[telemetry_monitor::strings::correlation_id].asInt64());
   EXPECT_EQ(obj["params"][application_manager::strings::connection_key].asInt(),
             jvalue[telemetry_monitor::strings::connection_key].asInt());
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
+  EXPECT_EQ(date_time::getuSecs(start_time),
             jvalue[telemetry_monitor::strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
+  EXPECT_EQ(date_time::getuSecs(end_time),
             jvalue[telemetry_monitor::strings::end].asInt64());
 
   EXPECT_NEAR(
diff --git a/src/components/telemetry_monitor/test/protocol_handler_metric_test.cc b/src/components/telemetry_monitor/test/protocol_handler_metric_test.cc
index f247f76866..c9130411e7 100644
--- a/src/components/telemetry_monitor/test/protocol_handler_metric_test.cc
+++ b/src/components/telemetry_monitor/test/protocol_handler_metric_test.cc
@@ -51,13 +51,10 @@ TEST(ProtocolHandlerMetricTest, grabResources) {
 TEST(ProtocolHandlerMetricTest, GetJsonMetric) {
   ProtocolHandlerMecticWrapper metric_test;
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
+
+  date_time::TimeDuration end_time = date_time::seconds(10);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
   metric_test.message_metric =
       std::make_shared<protocol_handler::PHTelemetryObserver::MessageMetric>();
   metric_test.message_metric->begin = start_time;
@@ -71,10 +68,8 @@ TEST(ProtocolHandlerMetricTest, GetJsonMetric) {
   EXPECT_EQ("null\n", jvalue[strings::utime].toStyledString());
   EXPECT_EQ("null\n", jvalue[strings::memory].toStyledString());
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
-            jvalue[strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
-            jvalue[strings::end].asInt64());
+  EXPECT_EQ(date_time::getuSecs(start_time), jvalue[strings::begin].asInt64());
+  EXPECT_EQ(date_time::getuSecs(end_time), jvalue[strings::end].asInt64());
   EXPECT_EQ(5, jvalue[strings::message_id].asInt64());
   EXPECT_EQ(2, jvalue[strings::connection_key].asInt());
 }
@@ -85,13 +80,10 @@ TEST(ProtocolHandlerMetricTest, GetJsonMetricWithGrabResources) {
   EXPECT_TRUE(resources != NULL);
   EXPECT_TRUE(metric_test.grabResources());
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
+
+  date_time::TimeDuration end_time = date_time::seconds(10);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
   metric_test.message_metric =
       std::make_shared<protocol_handler::PHTelemetryObserver::MessageMetric>();
   metric_test.message_metric->begin = start_time;
@@ -107,10 +99,8 @@ TEST(ProtocolHandlerMetricTest, GetJsonMetricWithGrabResources) {
   EXPECT_NE("null/n", jvalue[strings::utime].toStyledString());
   EXPECT_NE("null/n", jvalue[strings::memory].toStyledString());
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
-            jvalue[strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
-            jvalue[strings::end].asInt64());
+  EXPECT_EQ(date_time::getuSecs(start_time), jvalue[strings::begin].asInt64());
+  EXPECT_EQ(date_time::getuSecs(end_time), jvalue[strings::end].asInt64());
   EXPECT_EQ(5, jvalue[strings::message_id].asInt64());
   EXPECT_EQ(2, jvalue[strings::connection_key].asInt());
 
diff --git a/src/components/telemetry_monitor/test/protocol_handler_observer_test.cc b/src/components/telemetry_monitor/test/protocol_handler_observer_test.cc
index 3b2691bf72..587bf21ce6 100644
--- a/src/components/telemetry_monitor/test/protocol_handler_observer_test.cc
+++ b/src/components/telemetry_monitor/test/protocol_handler_observer_test.cc
@@ -47,9 +47,8 @@ TEST(ProtocolHandlerObserverTest, MessageProcess) {
 
   ProtocolHandlerObserver pr_handler(&mock_telemetry_monitor);
   uint32_t message_id = 1;
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
+
   pr_handler.StartMessageProcess(message_id, start_time);
 
   typedef protocol_handler::PHTelemetryObserver::MessageMetric MetricType;
@@ -64,9 +63,8 @@ TEST(ProtocolHandlerObserverTest, MessageProcessWithZeroMessageId) {
 
   ProtocolHandlerObserver pr_handler(&mock_telemetry_monitor);
   uint32_t message_id = 0;
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
+
   pr_handler.StartMessageProcess(message_id, start_time);
 
   typedef protocol_handler::PHTelemetryObserver::MessageMetric MetricType;
diff --git a/src/components/telemetry_monitor/test/transport_manager_metric_test.cc b/src/components/telemetry_monitor/test/transport_manager_metric_test.cc
index 99006c03ba..40caa6e0d6 100644
--- a/src/components/telemetry_monitor/test/transport_manager_metric_test.cc
+++ b/src/components/telemetry_monitor/test/transport_manager_metric_test.cc
@@ -51,13 +51,9 @@ TEST(TransportManagerMetricWrapper, grabResources) {
 TEST(TransportManagerMetricWrapper, GetJsonMetric) {
   TransportManagerMecticWrapper metric_test;
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
+  date_time::TimeDuration end_time = date_time::seconds(10);
   metric_test.message_metric =
       std::make_shared<transport_manager::TMTelemetryObserver::MessageMetric>();
   metric_test.message_metric->begin = start_time;
@@ -69,10 +65,8 @@ TEST(TransportManagerMetricWrapper, GetJsonMetric) {
   EXPECT_EQ("null\n", jvalue[strings::utime].toStyledString());
   EXPECT_EQ("null\n", jvalue[strings::memory].toStyledString());
 
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
-            jvalue[strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
-            jvalue[strings::end].asInt64());
+  EXPECT_EQ(date_time::getuSecs(start_time), jvalue[strings::begin].asInt64());
+  EXPECT_EQ(date_time::getuSecs(end_time), jvalue[strings::end].asInt64());
   EXPECT_EQ(1000, jvalue[strings::data_size].asInt());
 }
 
@@ -82,13 +76,9 @@ TEST(TransportManagerMetricWrapper, GetJsonMetricWithGrabResources) {
   EXPECT_TRUE(resources != NULL);
   EXPECT_TRUE(metric_test.grabResources());
 
-  TimevalStruct start_time;
-  start_time.tv_sec = 1;
-  start_time.tv_usec = 0;
+  date_time::TimeDuration start_time = date_time::seconds(1);
 
-  TimevalStruct end_time;
-  end_time.tv_sec = 10;
-  end_time.tv_usec = 0;
+  date_time::TimeDuration end_time = date_time::seconds(10);
   metric_test.message_metric =
       std::make_shared<transport_manager::TMTelemetryObserver::MessageMetric>();
   metric_test.message_metric->begin = start_time;
@@ -98,10 +88,8 @@ TEST(TransportManagerMetricWrapper, GetJsonMetricWithGrabResources) {
   Json::Value jvalue = metric_test.GetJsonMetric();
 
   EXPECT_EQ("\"TransportManager\"\n", jvalue[strings::logger].toStyledString());
-  EXPECT_EQ(date_time::DateTime::getuSecs(start_time),
-            jvalue[strings::begin].asInt64());
-  EXPECT_EQ(date_time::DateTime::getuSecs(end_time),
-            jvalue[strings::end].asInt64());
+  EXPECT_EQ(date_time::getuSecs(start_time), jvalue[strings::begin].asInt64());
+  EXPECT_EQ(date_time::getuSecs(end_time), jvalue[strings::end].asInt64());
   EXPECT_EQ(1000, jvalue[strings::data_size].asInt());
 
   EXPECT_NEAR(resources->stime, jvalue[strings::stime].asInt(), 1);
diff --git a/src/components/transport_manager/include/transport_manager/telemetry_observer.h b/src/components/transport_manager/include/transport_manager/telemetry_observer.h
index 5e42289a03..a38255966b 100644
--- a/src/components/transport_manager/include/transport_manager/telemetry_observer.h
+++ b/src/components/transport_manager/include/transport_manager/telemetry_observer.h
@@ -42,8 +42,8 @@ namespace transport_manager {
 class TMTelemetryObserver {
  public:
   struct MessageMetric {
-    TimevalStruct begin;
-    TimevalStruct end;
+    date_time::TimeDuration begin;
+    date_time::TimeDuration end;
     size_t data_size;
   };
   virtual void StartRawMsg(const protocol_handler::RawMessage* ptr) = 0;
diff --git a/src/components/utils/CMakeLists.txt b/src/components/utils/CMakeLists.txt
index 3177220de4..833c1dbc70 100644
--- a/src/components/utils/CMakeLists.txt
+++ b/src/components/utils/CMakeLists.txt
@@ -118,6 +118,7 @@ add_library("Utils" ${SOURCES})
 GET_PROPERTY(BOOST_LIBRARYDIRECTORY GLOBAL PROPERTY GLOBAL_BOOST_LIBS)
 list(APPEND LIBRARIES boost_system -L${BOOST_LIBRARYDIRECTORY})
 list(APPEND LIBRARIES boost_thread -L${BOOST_LIBRARYDIRECTORY})
+list(APPEND LIBRARIES boost_date_time -L${BOOST_LIBRARYDIRECTORY})
 target_link_libraries("Utils" ${LIBRARIES})
 add_dependencies("Utils" Boost)
 
diff --git a/src/components/utils/src/date_time.cc b/src/components/utils/src/date_time.cc
index fdf0926eb2..2802ed0f91 100644
--- a/src/components/utils/src/date_time.cc
+++ b/src/components/utils/src/date_time.cc
@@ -30,94 +30,69 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/time.h>
 #include <stdint.h>
+#include <sys/time.h>
 #include "utils/date_time.h"
 
+namespace bpt = boost::posix_time;
+using namespace boost::date_time;
 namespace date_time {
 
-TimevalStruct DateTime::getCurrentTime() {
-  TimevalStruct currentTime;
-  timezone timeZone;
-
-  gettimeofday(&currentTime, &timeZone);
+/* Set of helper functions for the TimeDuration struct
+ */
 
-  return currentTime;
+TimeDuration getCurrentTime() {
+  return bpt::microsec_clock::local_time() - bpt::from_time_t(0);
+}
+TimeDuration TimeDurationZero() {
+  return TimeDuration(0, 0, 0, 0);
+}
+int64_t getSecs(const TimeDuration& t) {
+  return t.total_seconds();
 }
 
-int64_t date_time::DateTime::getSecs(const TimevalStruct& time) {
-  const TimevalStruct times = ConvertionUsecs(time);
-  return static_cast<int64_t>(times.tv_sec);
+int64_t getmSecs(const TimeDuration& t) {
+  return t.total_milliseconds();
 }
 
-int64_t DateTime::getmSecs(const TimevalStruct& time) {
-  const TimevalStruct times = ConvertionUsecs(time);
-  return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND +
-         times.tv_usec / MICROSECONDS_IN_MILLISECOND;
+int64_t getuSecs(const TimeDuration& t) {
+  return t.total_microseconds();
 }
 
-int64_t DateTime::getuSecs(const TimevalStruct& time) {
-  const TimevalStruct times = ConvertionUsecs(time);
-  return static_cast<int64_t>(times.tv_sec) * MILLISECONDS_IN_SECOND *
-             MICROSECONDS_IN_MILLISECOND +
-         times.tv_usec;
+int64_t get_just_mSecs(const TimeDuration& t) {
+  return t.total_milliseconds() % MILLISECONDS_IN_SECOND;
 }
 
-int64_t DateTime::calculateTimeSpan(const TimevalStruct& sinceTime) {
-  return calculateTimeDiff(getCurrentTime(), sinceTime);
+int64_t get_just_uSecs(const TimeDuration& t) {
+  return t.total_microseconds() % MICROSECONDS_IN_SECOND;
 }
 
-int64_t DateTime::calculateTimeDiff(const TimevalStruct& time1,
-                                    const TimevalStruct& time2) {
-  const TimevalStruct times1 = ConvertionUsecs(time1);
-  const TimevalStruct times2 = ConvertionUsecs(time2);
-  TimevalStruct ret;
-  if (Greater(times1, times2)) {
-    ret = Sub(times1, times2);
-  } else {
-    ret = Sub(times2, times1);
-  }
-  return getmSecs(ret);
+int64_t calculateTimeSpan(const TimeDuration& sinceTime) {
+  return calculateTimeDiff(getCurrentTime(), sinceTime);
 }
 
-void DateTime::AddMilliseconds(TimevalStruct& time, uint32_t milliseconds) {
-  const uint32_t sec = milliseconds / MILLISECONDS_IN_SECOND;
-  const uint32_t usec =
-      (milliseconds % MILLISECONDS_IN_SECOND) * MICROSECONDS_IN_MILLISECOND;
-  time.tv_sec += sec;
-  time.tv_usec += usec;
-  time = ConvertionUsecs(time);
+int64_t calculateTimeDiff(const TimeDuration& time1,
+                          const TimeDuration& time2) {
+  return std::abs((time1 + -time2).total_milliseconds());
 }
 
-TimevalStruct DateTime::Sub(const TimevalStruct& time1,
-                            const TimevalStruct& time2) {
-  const TimevalStruct times1 = ConvertionUsecs(time1);
-  const TimevalStruct times2 = ConvertionUsecs(time2);
-  TimevalStruct ret;
-  timersub(&times1, &times2, &ret);
-  return ret;
+void AddMilliseconds(TimeDuration& t, uint32_t milliseconds) {
+  t += bpt::milliseconds(milliseconds);
 }
 
-bool DateTime::Greater(const TimevalStruct& time1, const TimevalStruct& time2) {
-  const TimevalStruct times1 = ConvertionUsecs(time1);
-  const TimevalStruct times2 = ConvertionUsecs(time2);
-  return timercmp(&times1, &times2, > );
+bool Greater(const TimeDuration& time1, const TimeDuration& time2) {
+  return time1 > time2;
 }
 
-bool DateTime::Less(const TimevalStruct& time1, const TimevalStruct& time2) {
-  const TimevalStruct times1 = ConvertionUsecs(time1);
-  const TimevalStruct times2 = ConvertionUsecs(time2);
-  return timercmp(&times1, &times2, < );
+bool Less(const TimeDuration& time1, const TimeDuration& time2) {
+  return time1 < time2;
 }
 
-bool DateTime::Equal(const TimevalStruct& time1, const TimevalStruct& time2) {
-  const TimevalStruct times1 = ConvertionUsecs(time1);
-  const TimevalStruct times2 = ConvertionUsecs(time2);
-  return !timercmp(&times1, &times2, != );
+bool Equal(const TimeDuration& time1, const TimeDuration& time2) {
+  return time1 == time2;
 }
 
-TimeCompare date_time::DateTime::compareTime(const TimevalStruct& time1,
-                                             const TimevalStruct& time2) {
+TimeCompare compareTime(const TimeDuration& time1, const TimeDuration& time2) {
   if (Greater(time1, time2))
     return GREATER;
   if (Less(time1, time2))
@@ -125,28 +100,4 @@ TimeCompare date_time::DateTime::compareTime(const TimevalStruct& time1,
   return EQUAL;
 }
 
-TimevalStruct date_time::DateTime::ConvertionUsecs(const TimevalStruct& time) {
-  if (time.tv_usec >= MICROSECONDS_IN_SECOND) {
-    TimevalStruct time1;
-    time1.tv_sec = static_cast<int64_t>(time.tv_sec) +
-                   (time.tv_usec / MICROSECONDS_IN_SECOND);
-    time1.tv_usec = static_cast<int64_t>(time.tv_usec) % MICROSECONDS_IN_SECOND;
-    return time1;
-  }
-  return time;
-}
-
 }  // namespace date_time
-
-bool operator<(const TimevalStruct& time1, const TimevalStruct& time2) {
-  return date_time::DateTime::Less(time1, time2);
-}
-
-bool operator==(const TimevalStruct& time1, const TimevalStruct& time2) {
-  return date_time::DateTime::Equal(time1, time2);
-}
-
-const TimevalStruct operator-(const TimevalStruct& time1,
-                              const TimevalStruct& time2) {
-  return date_time::DateTime::Sub(time1, time2);
-}
diff --git a/src/components/utils/test/date_time_test.cc b/src/components/utils/test/date_time_test.cc
index a209ab4d43..00085813aa 100644
--- a/src/components/utils/test/date_time_test.cc
+++ b/src/components/utils/test/date_time_test.cc
@@ -30,6 +30,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <boost/thread/thread.hpp>
 #include "gtest/gtest.h"
 #include "utils/date_time.h"
 
@@ -38,364 +39,270 @@ namespace components {
 namespace utils_test {
 
 using namespace date_time;
+
+namespace bpt = boost::posix_time;
 TEST(DateTimeTest, GetCurrentTime) {
   // arrange
-  const TimevalStruct time1 = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration time1 = getCurrentTime();
 
   // assert
-  ASSERT_NE(0, time1.tv_sec);
-  ASSERT_GE(time1.tv_usec, 0);
+  ASSERT_NE(0, time1.total_seconds());
+  ASSERT_GE(get_just_uSecs(time1), 0);
 
   // act
-  const TimevalStruct time2 = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration time2 = getCurrentTime();
 
   // assert
-  ASSERT_NE(0, time2.tv_sec);
-  ASSERT_GE(time2.tv_usec, 0);
-  ASSERT_GE(time2.tv_sec, time1.tv_sec);
+  ASSERT_NE(0, time2.total_seconds());
+  ASSERT_GE(get_just_uSecs(time1), 0);
+  ASSERT_GE(time2.total_seconds(), time1.total_seconds());
 }
 
 TEST(DateTimeTest, GetSecs) {
   // arrange
-  TimevalStruct time;
-  time.tv_sec = 1;
-  time.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time1 = bpt::seconds(1) + bpt::milliseconds(2);
 
   // assert
-  ASSERT_EQ(1, date_time::DateTime::getSecs(time));
+  ASSERT_EQ(1, getSecs(time1));
 }
 
 TEST(DateTimeTest, GetmSecs) {
   // arrange
-  TimevalStruct time;
-  time.tv_sec = 1;
-  time.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time1 = bpt::seconds(1) + bpt::milliseconds(2);
+  int expected = 1 * MILLISECONDS_IN_SECOND + 2;
 
-  int64_t expect_value =
-      time.tv_sec * date_time::DateTime::MILLISECONDS_IN_SECOND +
-      time.tv_usec / date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
   // assert
-  ASSERT_EQ(expect_value, date_time::DateTime::getmSecs(time));
+  ASSERT_EQ(expected, getmSecs(time1));
 }
 
 TEST(DateTimeTest, GetuSecs) {
   // arrange
-  TimevalStruct time;
-  time.tv_sec = 3;
-  time.tv_usec = 4;
-
-  int64_t expect_value = time.tv_sec *
-                             date_time::DateTime::MILLISECONDS_IN_SECOND *
-                             date_time::DateTime::MICROSECONDS_IN_MILLISECOND +
-                         time.tv_usec;
+  date_time::TimeDuration time1 = bpt::seconds(3) + bpt::microseconds(4);
+  int expect_value =
+      3 * MILLISECONDS_IN_SECOND * MICROSECONDS_IN_MILLISECOND + 4;
+
   // assert
-  ASSERT_EQ(expect_value, date_time::DateTime::getuSecs(time));
+  ASSERT_EQ(expect_value, getuSecs(time1));
 }
 
 TEST(DateTimeTest, GetuSecsmSecs) {
   // arrange
-  TimevalStruct time;
-  time.tv_sec = 5;
-  time.tv_usec = 6;
+  date_time::TimeDuration time1 = bpt::seconds(5) + bpt::microseconds(6);
 
-  int64_t expect_value = date_time::DateTime::getuSecs(time) /
-                         date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  int64_t expect_value = getuSecs(time1) / MICROSECONDS_IN_MILLISECOND;
 
   // assert
-  ASSERT_EQ(expect_value, date_time::DateTime::getmSecs(time));
+  ASSERT_EQ(expect_value, getmSecs(time1));
 }
 
 TEST(DateTimeTest, CalculateTimeSpan) {
   // arrange
-  const TimevalStruct time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration time1 = getCurrentTime();
 
   const uint32_t sleep_time_mSec = 10;
-  usleep(sleep_time_mSec * date_time::DateTime::MICROSECONDS_IN_MILLISECOND);
+  // sleep current thread
+  boost::this_thread::sleep(boost::posix_time::milliseconds(sleep_time_mSec));
 
   // assert
-  ASSERT_GE(date_time::DateTime::calculateTimeSpan(time), sleep_time_mSec);
+  ASSERT_GE(calculateTimeSpan(time1), sleep_time_mSec);
 }
 
 TEST(DateTimeTest, CalculateTimeDiff) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
 
-  TimevalStruct time2;
-  time2.tv_sec = 3;
-  time2.tv_usec = 4 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time1 = bpt::seconds(2) + bpt::milliseconds(2);
+  date_time::TimeDuration time2 = bpt::seconds(3) + bpt::milliseconds(4);
 
   // time2 to time1
-  TimevalStruct diff1;
-  diff1.tv_sec = time2.tv_sec - time1.tv_sec;
-  diff1.tv_usec = time2.tv_usec - time1.tv_usec;
-
-  const int64_t mSecDiff =
-      static_cast<int64_t>(diff1.tv_sec) * 1000 + diff1.tv_usec / 1000;
+  date_time::TimeDuration diff1 = bpt::seconds(1) + bpt::milliseconds(2);
 
   // assert
-  ASSERT_EQ(mSecDiff, date_time::DateTime::calculateTimeDiff(time2, time1));
+  ASSERT_EQ(diff1.total_milliseconds(), calculateTimeDiff(time2, time1));
 
-  // time1 to time2
-  TimevalStruct diff2;
-  diff2.tv_sec = time1.tv_sec - time2.tv_sec;
-  diff2.tv_usec = time1.tv_usec - time2.tv_usec;
-
-  const int64_t mSecDiff2 =
-      -(static_cast<int64_t>(diff2.tv_sec) * 1000 + diff2.tv_usec / 1000);
+  // time1 to time2, but calculateTimeDiff returns an absolute value
+  date_time::TimeDuration diff2 = -diff1.invert_sign();
 
   // assert
-  ASSERT_EQ(mSecDiff2, date_time::DateTime::calculateTimeDiff(time1, time2));
+  ASSERT_EQ(diff2.total_milliseconds(), calculateTimeDiff(time1, time2));
 }
 
 TEST(DateTimeTest, CalculateEqualTimeDiff) {
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time1 = bpt::seconds(1) + bpt::milliseconds(2);
 
-  TimevalStruct time2;
-  time2.tv_sec = 1;
-  time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time2 = bpt::seconds(1) + bpt::milliseconds(2);
 
-  ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time2, time1));
-  ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time1, time2));
+  ASSERT_EQ(0, calculateTimeDiff(time2, time1));
+  ASSERT_EQ(0, calculateTimeDiff(time1, time2));
 }
 
 TEST(DateTimeTest, compareTime) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time1 = bpt::seconds(1) + bpt::milliseconds(2);
 
-  TimevalStruct time2;
-  time2.tv_sec = 2;
-  time2.tv_usec = 4 * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+  date_time::TimeDuration time2 = bpt::seconds(2) + bpt::milliseconds(4);
 
   // assert
-  ASSERT_EQ(LESS, date_time::DateTime::compareTime(time1, time2));
-  ASSERT_EQ(GREATER, date_time::DateTime::compareTime(time2, time1));
-  ASSERT_NE(EQUAL, date_time::DateTime::compareTime(time2, time1));
+  ASSERT_EQ(LESS, compareTime(time1, time2));
+  ASSERT_EQ(GREATER, compareTime(time2, time1));
+  ASSERT_NE(EQUAL, compareTime(time2, time1));
 
   // act
-  TimevalStruct time3 = date_time::DateTime::Sub(time2, time1);
+  date_time::TimeDuration time3 = time2 - time1;
 
   // assert
-  ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time3));
+  ASSERT_EQ(EQUAL, compareTime(time1, time3));
 }
 
 TEST(DateTimeTest, GetSecs_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 0;
-  time1.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time1 = bpt::microseconds(MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_EQ(1, date_time::DateTime::getSecs(time1));
+  ASSERT_EQ(1, getSecs(time1));
 }
 
 TEST(DateTimeTest, compareTime_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time1 = bpt::seconds(1);
 
-  TimevalStruct time2;
-  time2.tv_sec = 0;
-  time2.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time2 = bpt::microseconds(MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_EQ(1, date_time::DateTime::getSecs(time1));
-  ASSERT_EQ(1, date_time::DateTime::getSecs(time2));
-  ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time2));
-}
-
-TEST(DateTimeTest, compareEqualTime_UsecConvertedInSec) {
-  // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 0;
-
-  TimevalStruct time2;
-  time2.tv_sec = 0;
-  time2.tv_usec = date_time::DateTime::MICROSECONDS_IN_SECOND;
-
-  // assert
-  ASSERT_TRUE(date_time::DateTime::Equal(time1, time2));
+  ASSERT_EQ(1, getSecs(time1));
+  ASSERT_EQ(1, getSecs(time2));
+  ASSERT_EQ(EQUAL, compareTime(time1, time2));
+  ASSERT_TRUE(Equal(time1, time2));
 }
 
 TEST(DateTimeTest, compareLessTime_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time1 = bpt::seconds(1);
 
-  TimevalStruct time2;
-  time2.tv_sec = 0;
-  time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time2 = bpt::microseconds(2 * MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_TRUE(date_time::DateTime::Less(time1, time2));
+  ASSERT_TRUE(Less(time1, time2));
 }
 
 TEST(DateTimeTest, compareGreaterTime_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time1 = bpt::seconds(1);
 
-  TimevalStruct time2;
-  time2.tv_sec = 0;
-  time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time2 = bpt::milliseconds(2 * MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_TRUE(date_time::DateTime::Greater(time2, time1));
+  ASSERT_TRUE(Greater(time2, time1));
 }
 
 TEST(DateTimeTest, CalculateTimeSub_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 1;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time1 = bpt::seconds(1);
 
-  TimevalStruct time2;
-  time2.tv_sec = 0;
-  time2.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time2 = bpt::microseconds(2 * MICROSECONDS_IN_SECOND);
 
-  TimevalStruct time3 = date_time::DateTime::Sub(time2, time1);
+  date_time::TimeDuration time3 = time2 - time1;
 
   // assert
-  ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time1, time3));
+  ASSERT_EQ(EQUAL, compareTime(time1, time3));
 }
 
 TEST(DateTimeTest, CalculateTimeDiff_UsecConvertedInSec) {
   // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 2;
-  time1.tv_usec = 5 * date_time::DateTime::MICROSECONDS_IN_SECOND;
 
-  TimevalStruct time2;
-  time2.tv_sec = 3;
-  time2.tv_usec = 1 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time1 =
+      bpt::seconds(2) + bpt::microseconds(5 * MICROSECONDS_IN_SECOND);
+  date_time::TimeDuration time2 =
+      bpt::seconds(3) + bpt::microseconds(1 * MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_EQ(3000, date_time::DateTime::calculateTimeDiff(time2, time1));
-  ASSERT_EQ(3000, date_time::DateTime::calculateTimeDiff(time1, time2));
+  ASSERT_EQ(3000, calculateTimeDiff(time2, time1));
+  ASSERT_EQ(3000, calculateTimeDiff(time1, time2));
 }
 
 TEST(DateTimeTest, CalculateEqualTimeDiff_UsecConvertedInSec) {
-  // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 2;
-  time1.tv_usec = 2 * date_time::DateTime::MICROSECONDS_IN_SECOND;
-
-  TimevalStruct time2;
-  time2.tv_sec = 3;
-  time2.tv_usec = 1 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time1 =
+      bpt::seconds(2) + bpt::microseconds(2 * MICROSECONDS_IN_SECOND);
+  date_time::TimeDuration time2 =
+      bpt::seconds(3) + bpt::microseconds(1 * MICROSECONDS_IN_SECOND);
 
   // assert
-  ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time2, time1));
-  ASSERT_EQ(0, date_time::DateTime::calculateTimeDiff(time1, time2));
-}
+  ASSERT_EQ(0, calculateTimeDiff(time2, time1));
+  ASSERT_EQ(0, calculateTimeDiff(time1, time2));
 
-TEST(DateTimeTest, CalculateEqualTimeSub_UsecConvertedInSec) {
-  // arrange
-  TimevalStruct time1;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time3 = time2 - time1;
+  date_time::TimeDuration time4 = time1 - time2;
 
-  TimevalStruct time2;
-  time2.tv_sec = 2;
-  time2.tv_usec = 1 * date_time::DateTime::MICROSECONDS_IN_SECOND;
+  date_time::TimeDuration time_expected(0, 0, 0, 0);
 
-  TimevalStruct time3 = date_time::DateTime::Sub(time2, time1);
-  TimevalStruct time4 = date_time::DateTime::Sub(time1, time2);
-
-  TimevalStruct time_expected;
-  time_expected.tv_sec = 0;
-  time_expected.tv_usec = 0;
-  // assert
-  ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time_expected, time3));
-  ASSERT_EQ(EQUAL, date_time::DateTime::compareTime(time_expected, time4));
+  ASSERT_EQ(EQUAL, compareTime(time_expected, time3));
+  ASSERT_EQ(EQUAL, compareTime(time_expected, time4));
 }
 
 TEST(DateTimeTest,
      AddMilliseconds_SetMillisecondMultiplesSecond_ExpectChangeTime) {
-  TimevalStruct time1;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
+  date_time::TimeDuration time1 = bpt::seconds(3);
   uint32_t milliseconds = 7000;
-  date_time::DateTime::AddMilliseconds(time1, milliseconds);
-  ASSERT_EQ(10, time1.tv_sec);
-  ASSERT_EQ(0, time1.tv_usec);
+  AddMilliseconds(time1, milliseconds);
+  ASSERT_EQ(10, getSecs(time1));
+  ASSERT_EQ(0, get_just_mSecs(time1));
 }
 
 TEST(DateTimeTest,
      AddMilliseconds_SetMillisecondNotMultiplesSecond_ExpectChangeTime) {
-  TimevalStruct time1;
+  date_time::TimeDuration time1 = bpt::seconds(3);
   uint32_t milliseconds = 7500;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
-  date_time::DateTime::AddMilliseconds(time1, milliseconds);
-  ASSERT_EQ(10, time1.tv_sec);
-  ASSERT_EQ(500000, time1.tv_usec);
+
+  AddMilliseconds(time1, milliseconds);
+  ASSERT_EQ(10, time1.total_seconds());
+  ASSERT_EQ(500000, get_just_uSecs(time1));
 }
 
 TEST(DateTimeTest,
      AddMilliseconds_SetMilliSecondLessThenSeconds_ExpectChangeTime) {
-  TimevalStruct time1;
+  date_time::TimeDuration time1 = bpt::seconds(3);
   uint32_t milliseconds = 500;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
-  date_time::DateTime::AddMilliseconds(time1, milliseconds);
-  ASSERT_EQ(3, time1.tv_sec);
-  ASSERT_EQ(500000, time1.tv_usec);
+
+  AddMilliseconds(time1, milliseconds);
+  ASSERT_EQ(3, getSecs(time1));
+  ASSERT_EQ(500000, get_just_uSecs(time1));
 }
 
 TEST(DateTimeTest,
      AddMilliseconds_SetMillisecondEqualNull_ExpectNotChangeTime) {
-  TimevalStruct time1;
+  date_time::TimeDuration time1 = bpt::seconds(3);
   uint32_t milliseconds = 0;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
-  date_time::DateTime::AddMilliseconds(time1, milliseconds);
-  ASSERT_EQ(3, time1.tv_sec);
-  ASSERT_EQ(0, time1.tv_usec);
+
+  AddMilliseconds(time1, milliseconds);
+  ASSERT_EQ(3, getSecs(time1));
+  ASSERT_EQ(0, get_just_mSecs(time1));
 }
 
 TEST(DateTimeTest, AddMilliseconds_SetOverlowMicrosecond_ExpectChangeTime) {
-  TimevalStruct time1;
+  date_time::TimeDuration time1 = bpt::seconds(3);
   uint32_t milliseconds = 7600;
-  time1.tv_sec = 3;
-  time1.tv_usec = 500000;
-  date_time::DateTime::AddMilliseconds(time1, milliseconds);
-  ASSERT_EQ(11, time1.tv_sec);
-  ASSERT_EQ(100000, time1.tv_usec);
+
+  AddMilliseconds(time1, milliseconds);
+  ASSERT_EQ(10, getSecs(time1));
+  ASSERT_EQ(600000, get_just_uSecs(time1));
 }
 
-TEST(DateTimeTest, Operator_minus_TimevalStruct_positive) {
-  TimevalStruct time1;
-  TimevalStruct time2;
-  TimevalStruct time3;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
-  time2.tv_sec = 3;
-  time2.tv_usec = 0;
-  time3.tv_sec = 2;
-  time3.tv_usec = 9000000;
-  ASSERT_EQ(0, date_time::DateTime::getSecs(time1 - time2));
-  ASSERT_EQ(8000000, date_time::DateTime::getuSecs(time3 - time1));
+TEST(DateTimeTest, Operator_minus_TimeDuration_positive) {
+  date_time::TimeDuration time1 = bpt::seconds(3);
+  date_time::TimeDuration time2 = bpt::seconds(3);
+  date_time::TimeDuration time3 =
+      bpt::seconds(2) + bpt::microseconds(9 * MICROSECONDS_IN_SECOND);
+  date_time::TimeDuration diff1 = time1 - time2;
+  ASSERT_EQ(0, getSecs(diff1));
+  ASSERT_EQ(8000000, getuSecs(time3 - time1));
 }
 
-TEST(DateTimeTest, Operator_minus_TimevalStruct_negative) {
-  TimevalStruct time1;
-  TimevalStruct time2;
-  time1.tv_sec = 3;
-  time1.tv_usec = 0;
-  time2.tv_sec = 2;
-  time2.tv_usec = 9000000;
-  ASSERT_NE(1, date_time::DateTime::getSecs(time1 - time2));
-  ASSERT_NE(-8000000, date_time::DateTime::getSecs(time2 - time1));
+TEST(DateTimeTest, Operator_minus_TimeDuration_negative) {
+  date_time::TimeDuration time1 = bpt::seconds(3);
+  date_time::TimeDuration time2 =
+      bpt::seconds(2) + bpt::microseconds(9 * MICROSECONDS_IN_SECOND);
+
+  ASSERT_NE(1, getSecs(time1 - time2));
+  ASSERT_NE(-8000000, getSecs(time2 - time1));
 }
 
 }  // namespace utils_test
diff --git a/src/components/utils/test/messagemeter_test.cc b/src/components/utils/test/messagemeter_test.cc
index 4ec14ac1cc..d45e600034 100644
--- a/src/components/utils/test/messagemeter_test.cc
+++ b/src/components/utils/test/messagemeter_test.cc
@@ -57,25 +57,25 @@ const TimePair testing_time_pairs[] = {TimePair(0, 50),
 class MessageMeterTest : public ::testing::TestWithParam<TimePair> {
  protected:
   void SetUp() OVERRIDE {
-    usecs = date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
+    usecs = date_time::MICROSECONDS_IN_MILLISECOND;
     id1 = 0x0;
     id2 = 0xABCDEF;
     id3 = 0xFEBCDA;
 
     const TimePair time_pair = GetParam();
     EXPECT_GT(usecs, time_pair.second) << "Wrong time (msecs) value";
+    time_range = date_time::seconds(time_pair.first) +
+                 date_time::microseconds(time_pair.second * usecs);
 
-    time_range.tv_sec = time_pair.first;
-    time_range.tv_usec = time_pair.second * usecs;
-    EXPECT_LT(0, date_time::DateTime::getuSecs(time_range))
+    EXPECT_LT(0, date_time::getuSecs(time_range))
         << "Wrong test case with null range value";
 
     meter.set_time_range(time_range);
-    time_range_msecs = date_time::DateTime::getmSecs(time_range);
+    time_range_msecs = date_time::getmSecs(time_range);
   }
   void TearDown() OVERRIDE {}
   ::utils::MessageMeter<int> meter;
-  TimevalStruct time_range = {0, 0};
+  date_time::TimeDuration time_range = date_time::TimeDurationZero();
   int64_t time_range_msecs;
   int usecs;
   int id1, id2, id3;
@@ -83,27 +83,25 @@ class MessageMeterTest : public ::testing::TestWithParam<TimePair> {
 
 TEST(MessageMeterTest, DefaultTimeRange) {
   const ::utils::MessageMeter<int> default_meter;
-  const TimevalStruct time_second{1, 0};
+  const date_time::TimeDuration time_second = date_time::seconds(1);
   EXPECT_EQ(time_second, default_meter.time_range());
 }
 
 TEST(MessageMeterTest, TimeRangeSetter) {
   ::utils::MessageMeter<int> meter;
-  TimevalStruct time_range{0, 0};
+  date_time::TimeDuration time_range;
   const int test_count_secs = 1000;
-  // Skip 1000th msec value as wrong for TimevalStruct
+  // Skip 1000th msec value as wrong for date_time::TimeDuration
   const int test_count_msecs = 999;
   for (int sec = test_count_secs; sec >= 0; --sec) {
     for (int msec = test_count_msecs; msec >= 0; --msec) {
-      time_range.tv_sec = sec;
-      time_range.tv_usec =
-          msec * date_time::DateTime::MICROSECONDS_IN_MILLISECOND;
-      // Setter TimevalStruct
+      time_range = date_time::seconds(sec) + date_time::milliseconds(msec);
+
+      // Setter date_time::TimeDuration
       meter.set_time_range(time_range);
       EXPECT_EQ(time_range, meter.time_range()) << sec << "." << msec << " sec";
       // Setter mSecs
-      meter.set_time_range(sec * date_time::DateTime::MILLISECONDS_IN_SECOND +
-                           msec);
+      meter.set_time_range(sec * date_time::MILLISECONDS_IN_SECOND + msec);
       EXPECT_EQ(time_range, meter.time_range()) << sec << "." << msec << " sec";
     }
   }
@@ -113,7 +111,7 @@ TEST(MessageMeterTest, AddingWithNullTimeRange) {
   ::utils::MessageMeter<int> meter;
   const int id1 = 1;
   const int id2 = 2;
-  const TimevalStruct null_time_range{0, 0};
+  const date_time::TimeDuration null_time_range = date_time::TimeDurationZero();
   meter.set_time_range(null_time_range);
   for (int i = 0; i < 10000; ++i) {
     // 1st Connection
@@ -129,10 +127,10 @@ TEST(MessageMeterTest, AddingWithNullTimeRange) {
 TEST_P(MessageMeterTest,
        DISABLED_TrackMessage_AddingOverPeriod_CorrectCountOfMessages) {
   size_t messages = 0;
-  const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration start_time = date_time::getCurrentTime();
   // Add messages for less range period
   int64_t time_span;
-  while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) <
+  while ((time_span = date_time::calculateTimeSpan(start_time)) <
          time_range_msecs) {
     ++messages;
 
@@ -153,10 +151,10 @@ TEST_P(MessageMeterTest,
 TEST_P(MessageMeterTest,
        DISABLED_TrackMessage_AddingOverPeriodMultiIds_CorrectCountOfMessages) {
   size_t messages = 0;
-  const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration start_time = date_time::getCurrentTime();
   // Add messages for less range period
   int64_t time_span;
-  while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) <
+  while ((time_span = date_time::calculateTimeSpan(start_time)) <
          time_range_msecs) {
     ++messages;
 
@@ -188,14 +186,14 @@ TEST_P(MessageMeterTest,
 TEST_P(MessageMeterTest,
        DISABLED_Frequency_CountingOverPeriod_CorrectCountOfMessages) {
   const size_t one_message = 1;
-  const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+  const date_time::TimeDuration start_time = date_time::getCurrentTime();
   EXPECT_EQ(one_message, meter.TrackMessage(id1));
   EXPECT_EQ(one_message, meter.TrackMessage(id2));
   EXPECT_EQ(one_message, meter.TrackMessage(id3));
 
   // Check messages count over period
   int64_t time_span;
-  while ((time_span = date_time::DateTime::calculateTimeSpan(start_time)) <
+  while ((time_span = date_time::calculateTimeSpan(start_time)) <
          time_range_msecs) {
     usleep(time_range_msecs);