diff --git a/CMakeLists.txt b/CMakeLists.txt
index b1971d2..f5b913a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,28 +106,28 @@
 
 #g3 logging
 # G3logger does some unfortunate compile options, so cheat a little bit and copy/paste
-set(LOG_SRC ${CMAKE_CURRENT_SOURCE_DIR}/g3log)
+#set(LOG_SRC ${CMAKE_CURRENT_SOURCE_DIR}/g3log)
 
-file(GLOB_RECURSE SRC_FILES ${LOG_SRC}/*.cpp ${LOG_SRC}/*.ipp)
-file(GLOB_RECURSE HEADER_FILES ${LOG_SRC}/*.hpp)
+#file(GLOB_RECURSE SRC_FILES ${LOG_SRC}/*.cpp ${LOG_SRC}/*.ipp)
+#file(GLOB_RECURSE HEADER_FILES ${LOG_SRC}/*.hpp)
 
-IF (MSVC OR MINGW)
-    list(REMOVE_ITEM SRC_FILES  ${LOG_SRC}/crashhandler_unix.cpp)
-ELSE()
-    list(REMOVE_ITEM SRC_FILES  ${LOG_SRC}/crashhandler_windows.cpp ${LOG_SRC}/g3log/stacktrace_windows.hpp ${LOG_SRC}/stacktrace_windows.cpp)
-ENDIF (MSVC OR MINGW)
+#IF (MSVC OR MINGW)
+#    list(REMOVE_ITEM SRC_FILES  ${LOG_SRC}/crashhandler_unix.cpp)
+#ELSE()
+#    list(REMOVE_ITEM SRC_FILES  ${LOG_SRC}/crashhandler_windows.cpp ${LOG_SRC}/g3log/stacktrace_windows.hpp ${LOG_SRC}/stacktrace_windows.cpp)
+#ENDIF (MSVC OR MINGW)
 
 # Create the g3log library
-include_directories(${LOG_SRC})
+#include_directories(${LOG_SRC})
 
-add_library(g3logger ${SRC_FILES})
-set_target_properties(g3logger PROPERTIES LINKER_LANGUAGE CXX)
+#add_library(g3logger ${SRC_FILES})
+#set_target_properties(g3logger PROPERTIES LINKER_LANGUAGE CXX)
 # clean up some warnings in files we don't own
-if(("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"))
-    set_source_files_properties(g3log/src/logcapture.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
-    set_source_files_properties(g3log/src/filesink.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
-    set_source_files_properties(g3log/src/logworker.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
-endif()
+#if(("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"))
+#    set_source_files_properties(g3log/src/logcapture.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
+#    set_source_files_properties(g3log/src/filesink.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
+#    set_source_files_properties(g3log/src/logworker.cpp PROPERTIES COMPILE_FLAGS -Wno-braced-scalar-init)
+#endif()
 
 #lib jpeg
 set(BUILD_STATIC ON)
@@ -230,7 +230,7 @@
     add_executable(webtest ${HDR_FILES} ${SRC_FILES} ${UT_FILES})
     target_link_libraries(webtest gmock gtest)
     target_link_libraries(webtest pthread)
-    target_link_libraries(webtest g3logger)
+    #target_link_libraries(webtest g3logger)
     
     target_link_libraries(webtest ${OPENSSL_LIBRARIES})
     target_link_libraries(webtest ${ZLIB_LIBRARIES})
@@ -247,7 +247,7 @@
 # bmcweb
 add_executable(bmcweb ${WEBSERVER_MAIN} ${HDR_FILES} ${SRC_FILES})
 target_link_libraries(bmcweb pthread)
-target_link_libraries(bmcweb g3logger)
+#target_link_libraries(bmcweb g3logger)
 target_link_libraries(bmcweb ${OPENSSL_LIBRARIES})
 target_link_libraries(bmcweb ${ZLIB_LIBRARIES})
 target_link_libraries(bmcweb  ${DBUS_LIBRARIES})
@@ -257,7 +257,7 @@
 
 add_executable(getvideo src/getvideo_main.cpp)
 target_link_libraries(getvideo pthread)
-target_link_libraries(getvideo g3logger)
+#target_link_libraries(getvideo g3logger)
 
 # Visual Studio Code helper
 # this needs to be at the end to make sure all includes are handled correctly
diff --git a/boost-dbus/CMakeLists.txt b/boost-dbus/CMakeLists.txt
index 9d07a5b..736d030 100644
--- a/boost-dbus/CMakeLists.txt
+++ b/boost-dbus/CMakeLists.txt
@@ -20,7 +20,11 @@
 
 ###############
 # import Boost
+add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY)
+add_definitions(-DBOOST_SYSTEM_NO_DEPRECATED)
+add_definitions(-DBOOST_ALL_NO_LIB)
 find_package(Boost REQUIRED)
+
 include_directories(${Boost_INCLUDE_DIRS})
 link_directories(${Boost_LIBRARY_DIRS})
 
diff --git a/boost-dbus/include/dbus/element.hpp b/boost-dbus/include/dbus/element.hpp
index 276b593..32cdcdc 100644
--- a/boost-dbus/include/dbus/element.hpp
+++ b/boost-dbus/include/dbus/element.hpp
@@ -8,7 +8,9 @@
 
 #include <dbus/dbus.h>
 #include <string>
+#include <vector>
 #include <boost/cstdint.hpp>
+#include <boost/variant.hpp>
 
 namespace dbus {
 
@@ -31,6 +33,11 @@
 // unix_fd
 
 typedef std::string string;
+
+typedef boost::variant<std::string, bool, byte, int16, uint16, int32, uint32, int64,
+                       uint64, double>
+    dbus_variant;
+
 struct object_path {
   string value;
 };
@@ -97,6 +104,16 @@
   static const int code = DBUS_TYPE_STRING;
 };
 
+template <typename Element>
+struct element<std::vector<Element>> {
+  static const int code = DBUS_TYPE_ARRAY;
+};
+
+template <>
+struct element<dbus_variant> {
+  static const int code = DBUS_TYPE_VARIANT;
+};
+
 template <>
 struct element<object_path> {
   static const int code = DBUS_TYPE_OBJECT_PATH;
diff --git a/boost-dbus/include/dbus/impl/message_iterator.hpp b/boost-dbus/include/dbus/impl/message_iterator.hpp
index 44bcf2e..6969b8b 100644
--- a/boost-dbus/include/dbus/impl/message_iterator.hpp
+++ b/boost-dbus/include/dbus/impl/message_iterator.hpp
@@ -34,7 +34,8 @@
 
   bool next();
   bool has_next();
-  int get_arg_type();
+  char get_arg_type();
+  int get_element_count();
 
   void get_basic(void *value);
 
diff --git a/boost-dbus/include/dbus/impl/message_iterator.ipp b/boost-dbus/include/dbus/impl/message_iterator.ipp
index eb2584f..034f658 100644
--- a/boost-dbus/include/dbus/impl/message_iterator.ipp
+++ b/boost-dbus/include/dbus/impl/message_iterator.ipp
@@ -58,7 +58,12 @@
   return dbus_message_iter_has_next(&DBusMessageIter_);
 }
 
-inline int message_iterator::get_arg_type()
+inline int message_iterator::get_element_count()
+{
+  return dbus_message_iter_get_element_count(&DBusMessageIter_);
+}
+
+inline char message_iterator::get_arg_type()
 {
   return dbus_message_iter_get_arg_type(&DBusMessageIter_);
 }
diff --git a/boost-dbus/include/dbus/message.hpp b/boost-dbus/include/dbus/message.hpp
index aa5e89c..695e1fc 100644
--- a/boost-dbus/include/dbus/message.hpp
+++ b/boost-dbus/include/dbus/message.hpp
@@ -104,6 +104,7 @@
   struct packer {
     impl::message_iterator iter_;
     packer(message& m) { impl::message_iterator::init_append(m, iter_); }
+    packer(){};
     template <typename Element>
     packer& pack(const Element& e) {
       return *this << e;
@@ -112,6 +113,7 @@
   struct unpacker {
     impl::message_iterator iter_;
     unpacker(message& m) { impl::message_iterator::init(m, iter_); }
+    unpacker() {}
 
     template <typename Element>
     unpacker& unpack(Element& e) {
@@ -147,16 +149,106 @@
   return p;
 }
 
+template <typename Key, typename Value>
+message::packer& operator<<(message::packer& p,
+                            const std::vector<std::pair<Key, Value>>& v) {
+  message::packer sub;
+  char signature[] = {'{', element<Key>::code, element<Value>::code, '}', 0};
+
+  p.iter_.open_container(DBUS_TYPE_ARRAY, signature, sub.iter_);
+  for (auto& element : v) {
+    sub << element;
+  }
+
+  p.iter_.close_container(sub.iter_);
+  return p;
+}
+
+template <typename Element>
+message::packer& operator<<(message::packer& p, const std::vector<Element>& v) {
+  message::packer sub;
+  char signature[] = {element<Element>::code, 0};
+  p.iter_.open_container(element<std::vector<Element>>::code, signature,
+                         sub.iter_);
+  for (auto& element : v) {
+    sub << element;
+  }
+
+  p.iter_.close_container(sub.iter_);
+  return p;
+}
+
 inline message::packer& operator<<(message::packer& p, const char* c) {
   p.iter_.append_basic(element<string>::code, &c);
   return p;
 }
 
+template <typename Key, typename Value>
+inline message::packer& operator<<(message::packer& p,
+                                   const std::pair<Key, Value> element) {
+  message::packer dict_entry;
+  p.iter_.open_container(DBUS_TYPE_DICT_ENTRY, NULL, dict_entry.iter_);
+  dict_entry << element.first;
+  dict_entry << element.second;
+  p.iter_.close_container(dict_entry.iter_);
+  return p;
+}
+
 inline message::packer& operator<<(message::packer& p, const string& e) {
   const char* c = e.c_str();
   return p << c;
 }
 
+inline message::packer& operator<<(message::packer& p, const dbus_variant& v) {
+  message::packer sub;
+  char type = 0;
+  // TODO(ed) there must be a better (more typesafe) way to do this
+  switch (v.which()) {
+    case 0:
+      type = element<std::string>::code;
+      break;
+    case 1:
+      type = element<bool>::code;
+      break;
+    case 2:
+      type = element<byte>::code;
+      break;
+    case 3:
+      type = element<int16>::code;
+      break;
+    case 4:
+      type = element<uint16>::code;
+      break;
+    case 5:
+      type = element<int32>::code;
+      break;
+    case 6:
+      type = element<uint32>::code;
+      break;
+    case 7:
+      type = element<int64>::code;
+      break;
+    case 8:
+      type = element<uint64>::code;
+      break;
+    case 9:
+      type = element<double>::code;
+      break;
+
+    default:
+      // TODO(ed) throw exception
+      break;
+  }
+  char signature[] = {type, 0};
+
+  p.iter_.open_container(element<dbus_variant>::code, signature, sub.iter_);
+  boost::apply_visitor([&](auto val) { sub << val; }, v);
+  // sub << element;
+  p.iter_.close_container(sub.iter_);
+
+  return p;
+}
+
 template <typename Element>
 message::unpacker operator>>(message m, Element& e) {
   return message::unpacker(m).unpack(e);
@@ -178,32 +270,98 @@
   return u;
 }
 
+inline message::unpacker& operator>>(message::unpacker& u, dbus_variant& v) {
+  message::unpacker sub;
+  u.iter_.recurse(sub.iter_);
+
+  auto arg_type = sub.iter_.get_arg_type();
+  // sub.iter_.get_basic(&c);
+  // Todo(ed) find a better way to do this lookup table
+  switch (arg_type) {
+    case element<std::string>::code: {
+      std::string s;
+      sub >> s;
+      v = s;
+    } break;
+    case element<bool>::code: {
+      bool b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<byte>::code: {
+      byte b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<int16>::code: {
+      int16 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<uint16>::code: {
+      uint16 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<int32>::code: {
+      int32 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<uint32>::code: {
+      uint32 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<int64>::code: {
+      int64 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<uint64>::code: {
+      uint64 b;
+      sub >> b;
+      v = b;
+    } break;
+    case element<double>::code: {
+      double b;
+      sub >> b;
+      v = b;
+    } break;
+
+    default:
+      // TODO(ed) throw exception
+      break;
+  }
+  u.iter_.next();
+  return u;
+}
+
+template <typename Key, typename Value>
+inline message::unpacker& operator>>(message::unpacker& u,
+                                     std::pair<Key, Value>& v) {
+  message::unpacker sub;
+  u.iter_.recurse(sub.iter_);
+  sub >> v.first;
+  sub >> v.second;
+
+  u.iter_.next();
+  return u;
+}
+
 template <typename Element>
 inline message::unpacker& operator>>(message::unpacker& u,
                                      std::vector<Element>& s) {
-  static_assert(std::is_same<Element, std::string>::value,
-                "only std::vector<std::string> is implemented for now");
-  impl::message_iterator sub;
-  u.iter_.recurse(sub);
+  message::unpacker sub;
 
-  const char* c;
-  while (sub.has_next()) {
-    sub.get_basic(&c);
-    s.emplace_back(c);
-    sub.next();
-  }
-
-  // TODO(ed)
-  // Make this generic for all types.  The below code is close, but there's
-  // template issues and things I don't understand;
-  /*
-  auto e = message::unpacker(sub);
-  while (sub.has_next()) {
+  u.iter_.recurse(sub.iter_);
+  auto arg_type = sub.iter_.get_arg_type();
+  while (arg_type != DBUS_TYPE_INVALID) {
     s.emplace_back();
-    Element& element = s.back();
-    e.unpack(element);
+    sub >> s.back();
+    arg_type = sub.iter_.get_arg_type();
   }
-*/
+  u.iter_.next();
   return u;
 }
 
diff --git a/boost-dbus/test/avahi.cpp b/boost-dbus/test/avahi.cpp
index debbff3..8cbb82f 100644
--- a/boost-dbus/test/avahi.cpp
+++ b/boost-dbus/test/avahi.cpp
@@ -150,27 +150,114 @@
   }
 }
 
-TEST(BOOST_DBUS, ListObjects) {
+TEST(BOOST_DBUS, SingleSensorChanged) {
   boost::asio::io_service io;
   dbus::connection system_bus(io, dbus::bus::system);
 
-  dbus::endpoint test_daemon("org.freedesktop.DBus", "/",
-                             "org.freedesktop.DBus");
+  dbus::match ma(system_bus,
+                 "type='signal',path_namespace='/xyz/openbmc_project/sensors'");
+  dbus::filter f(system_bus, [](dbus::message& m) {
+    auto member = m.get_member();
+    return member == "PropertiesChanged";
+  });
 
-  // create new service browser
-  dbus::message m = dbus::message::new_call(test_daemon, "ListNames");
-  auto r = system_bus.send(m);
+  // std::function<void(boost::system::error_code, dbus::message)> event_handler
+  // =
 
-  std::vector<std::string> services;
-  r.unpack(services);
-  // todo(ed) find out why this needs to be static
-  static std::atomic<int> dbus_count(0);
-  std::cout << dbus_count << " Callers\n";
-  auto names = std::make_shared<std::vector<std::string>>();
-  for (auto& service : services) {
-    std::string name = "/";
-    query_interfaces(system_bus, service, name);
-  }
+  f.async_dispatch([&](boost::system::error_code ec, dbus::message s) {
+    std::string object_name;
+    EXPECT_EQ(s.get_path(),
+              "/xyz/openbmc_project/sensors/temperature/LR_Brd_Temp");
+
+    std::vector<std::pair<std::string, dbus::dbus_variant>> values;
+    s.unpack(object_name).unpack(values);
+
+    EXPECT_EQ(object_name, "xyz.openbmc_project.Sensor.Value");
+
+    EXPECT_EQ(values.size(), 1);
+    auto expected = std::pair<std::string, dbus::dbus_variant>("Value", 42);
+    EXPECT_EQ(values[0], expected);
+
+    io.stop();
+  });
+
+  dbus::endpoint test_endpoint(
+      "org.freedesktop.Avahi",
+      "/xyz/openbmc_project/sensors/temperature/LR_Brd_Temp",
+      "org.freedesktop.DBus.Properties");
+
+  auto signal_name = std::string("PropertiesChanged");
+  auto m = dbus::message::new_signal(test_endpoint, signal_name);
+
+  m.pack("xyz.openbmc_project.Sensor.Value");
+
+  std::vector<std::pair<std::string, dbus::dbus_variant>> map2;
+
+  map2.emplace_back("Value", 42);
+
+  m.pack(map2);
+
+  auto removed = std::vector<uint32_t>();
+  m.pack(removed);
+  system_bus.async_send(m,
+                        [&](boost::system::error_code ec, dbus::message s) {});
 
   io.run();
 }
+
+TEST(BOOST_DBUS, MultipleSensorChanged) {
+  boost::asio::io_service io;
+  dbus::connection system_bus(io, dbus::bus::system);
+
+  dbus::match ma(system_bus,
+                 "type='signal',path_namespace='/xyz/openbmc_project/sensors'");
+  dbus::filter f(system_bus, [](dbus::message& m) {
+    auto member = m.get_member();
+    return member == "PropertiesChanged";
+  });
+
+  int count = 0;
+  f.async_dispatch([&](boost::system::error_code ec, dbus::message s) {
+    std::string object_name;
+    EXPECT_EQ(s.get_path(),
+              "/xyz/openbmc_project/sensors/temperature/LR_Brd_Temp");
+
+    std::vector<std::pair<std::string, dbus::dbus_variant>> values;
+    s.unpack(object_name).unpack(values);
+
+    EXPECT_EQ(object_name, "xyz.openbmc_project.Sensor.Value");
+
+    EXPECT_EQ(values.size(), 1);
+    auto expected = std::pair<std::string, dbus::dbus_variant>("Value", 42);
+    EXPECT_EQ(values[0], expected);
+    count++;
+    if (count == 2) {
+      io.stop();
+    }
+
+  });
+
+  dbus::endpoint test_endpoint(
+      "org.freedesktop.Avahi",
+      "/xyz/openbmc_project/sensors/temperature/LR_Brd_Temp",
+      "org.freedesktop.DBus.Properties");
+
+  auto signal_name = std::string("PropertiesChanged");
+  auto m = dbus::message::new_signal(test_endpoint, signal_name);
+
+  m.pack("xyz.openbmc_project.Sensor.Value");
+
+  std::vector<std::pair<std::string, dbus::dbus_variant>> map2;
+
+  map2.emplace_back("Value", 42);
+
+  m.pack(map2);
+
+  auto removed = std::vector<uint32_t>();
+  m.pack(removed);
+  system_bus.async_send(m,
+                        [&](boost::system::error_code ec, dbus::message s) {});
+  system_bus.async_send(m,
+                        [&](boost::system::error_code ec, dbus::message s) {});
+  io.run();
+}
\ No newline at end of file
diff --git a/boost-dbus/test/message.cpp b/boost-dbus/test/message.cpp
index d591f61..8c8169f 100644
--- a/boost-dbus/test/message.cpp
+++ b/boost-dbus/test/message.cpp
@@ -3,9 +3,9 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <dbus/error.hpp>
 #include <dbus/connection.hpp>
 #include <dbus/endpoint.hpp>
+#include <dbus/error.hpp>
 #include <dbus/filter.hpp>
 #include <dbus/match.hpp>
 #include <dbus/message.hpp>
@@ -35,6 +35,21 @@
   // m.get_sender();
 }
 
+TEST(MessageTest, Misc) {
+    auto signal_name = std::string("PropertiesChanged");
+  dbus::endpoint test_endpoint(
+      "org.freedesktop.Avahi",
+      "/xyz/openbmc_project/sensors/temperature/LR_Brd_Temp",
+      "org.freedesktop.DBus.Properties");
+  auto m = dbus::message::new_signal(test_endpoint, signal_name);
+
+  dbus::dbus_variant v(std::string("hello world"));
+  m.pack(v);
+
+  std::vector<dbus::dbus_variant> av{{std::string("hello world"), 1, 42}};
+  m.pack(av);
+}
+
 // I actually don't know what to do with these yet.
 /*
 TEST(MessageTest, ErrorMessage)
diff --git a/crow/include/crow/http_server.h b/crow/include/crow/http_server.h
index 5ed2927..b0d63d3 100644
--- a/crow/include/crow/http_server.h
+++ b/crow/include/crow/http_server.h
@@ -140,10 +140,9 @@
 
     do_accept();
 
-    std::thread([this] {
-      io_service_.run();
-      CROW_LOG_INFO << "Exiting.";
-    }).join();
+    io_service_.run();
+    CROW_LOG_INFO << "Exiting.";
+
   }
 
   void stop() {
diff --git a/crow/include/crow/logging.h b/crow/include/crow/logging.h
index bfdedb9..4e142b1 100644
--- a/crow/include/crow/logging.h
+++ b/crow/include/crow/logging.h
@@ -1,3 +1,141 @@
 #pragma once
 
-#include <crow/g3_logger.hpp>
\ No newline at end of file
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+#include <sstream>
+
+#include "crow/settings.h"
+
+namespace crow
+{
+    enum class LogLevel
+    {
+#ifndef ERROR
+        DEBUG = 0,
+        INFO,
+        WARNING,
+        ERROR,
+        CRITICAL,
+#endif
+
+        Debug = 0,
+        Info,
+        Warning,
+        Error,
+        Critical,
+    };
+
+    class ILogHandler {
+        public:
+            virtual void log(std::string message, LogLevel level) = 0;
+    };
+
+    class CerrLogHandler : public ILogHandler {
+        public:
+            void log(std::string message, LogLevel /*level*/) override {
+                std::cerr << message;
+            }
+    };
+
+    class logger {
+
+        private:
+            //
+            static std::string timestamp()
+            {
+                char date[32];
+                time_t t = time(0);
+
+                tm my_tm;
+
+#ifdef _MSC_VER
+                gmtime_s(&my_tm, &t);
+#else
+                gmtime_r(&t, &my_tm);
+#endif
+
+                size_t sz = strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", &my_tm);
+                return std::string(date, date+sz);
+            }
+
+        public:
+
+
+            logger(std::string prefix, LogLevel level) : level_(level) {
+    #ifdef CROW_ENABLE_LOGGING
+                    stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
+    #endif
+
+            }
+            ~logger() {
+    #ifdef CROW_ENABLE_LOGGING
+                if(level_ >= get_current_log_level()) {
+                    stringstream_ << std::endl;
+                    get_handler_ref()->log(stringstream_.str(), level_);
+                }
+    #endif
+            }
+
+            //
+            template <typename T>
+            logger& operator<<(T const &value) {
+
+    #ifdef CROW_ENABLE_LOGGING
+                if(level_ >= get_current_log_level()) {
+                    stringstream_ << value;
+                }
+    #endif
+                return *this;
+            }
+
+            //
+            static void setLogLevel(LogLevel level) {
+                get_log_level_ref() = level;
+            }
+
+            static void setHandler(ILogHandler* handler) {
+                get_handler_ref() = handler;
+            }
+
+            static LogLevel get_current_log_level() {
+                return get_log_level_ref();
+            }
+
+        private:
+            //
+            static LogLevel& get_log_level_ref()
+            {
+                static LogLevel current_level = (LogLevel)CROW_LOG_LEVEL;
+                return current_level;
+            }
+            static ILogHandler*& get_handler_ref()
+            {
+                static CerrLogHandler default_handler;
+                static ILogHandler* current_handler = &default_handler;
+                return current_handler;
+            }
+
+            //
+            std::ostringstream stringstream_;
+            LogLevel level_;
+    };
+}
+
+#define CROW_LOG_CRITICAL   \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::Critical) \
+            crow::logger("CRITICAL", crow::LogLevel::Critical)
+#define CROW_LOG_ERROR      \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::Error) \
+            crow::logger("ERROR   ", crow::LogLevel::Error)
+#define CROW_LOG_WARNING    \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::Warning) \
+            crow::logger("WARNING ", crow::LogLevel::Warning)
+#define CROW_LOG_INFO       \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::Info) \
+            crow::logger("INFO    ", crow::LogLevel::Info)
+#define CROW_LOG_DEBUG      \
+        if (crow::logger::get_current_log_level() <= crow::LogLevel::Debug) \
+            crow::logger("DEBUG   ", crow::LogLevel::Debug)
diff --git a/crow/include/crow/websocket.h b/crow/include/crow/websocket.h
index 65a5836..cfd75d8 100644
--- a/crow/include/crow/websocket.h
+++ b/crow/include/crow/websocket.h
@@ -71,7 +71,7 @@
     adaptor_.get_io_service().post(handler);
   }
 
-  boost::asio::io_service& get_io_service(){
+  boost::asio::io_service& get_io_service() override {
     return adaptor_.get_io_service();
   }
 
@@ -143,7 +143,7 @@
         "HTTP/1.1 101 Switching Protocols\r\n"
         "Upgrade: websocket\r\n"
         "Connection: Upgrade\r\n"
-        "Sec-WebSocket-Protocol: binary\r\n"  // TODO(ed): this hardcodes binary mode
+        //"Sec-WebSocket-Protocol: binary\r\n"  // TODO(ed): this hardcodes binary mode
                                             // find a better way
         "Sec-WebSocket-Accept: ";
     static std::string crlf = "\r\n";
diff --git a/docs/profile.md b/docs/profile.md
index b6dcf98..b3ceff0 100644
--- a/docs/profile.md
+++ b/docs/profile.md
@@ -12,4 +12,7 @@
 scp ed@hades.jf.intel.com:/home/ed/webserver/buildarm/getvideo /tmp -i /nv/.ssh/id_rsa && cd /tmp && ./getvideo && scp screen.jpg ed@hades.jf.intel.com:~/screen.foo -i /nv/.ssh/id_rsa
 
 
-kill -12 1480
\ No newline at end of file
+kill -12 1480
+
+
+dbus-monitor --system "type='signal',path_namespace='/xyz/openbmc_project/sensors'"
\ No newline at end of file
diff --git a/g3log/g3log.cpp b/g3log/g3log.cpp
index 86a437b..9b6539a 100644
--- a/g3log/g3log.cpp
+++ b/g3log/g3log.cpp
@@ -141,7 +141,7 @@
        */
       bool shutDownLoggingForActiveOnly(LogWorker *active) {
          if (isLoggingInitialized() && nullptr != active && (active != g_logger_instance)) {
-            LOG(WARNING) << "\n\t\tAttempted to shut down logging, but the ID of the Logger is not the one that is active."
+            std::cerr << "\n\t\tAttempted to shut down logging, but the ID of the Logger is not the one that is active."
                          << "\n\t\tHaving multiple instances of the g3::LogWorker is likely a BUG"
                          << "\n\t\tEither way, this call to shutDownLogging was ignored"
                          << "\n\t\tTry g3::internal::shutDownLogging() instead";
diff --git a/include/ast_jpeg_decoder.hpp b/include/ast_jpeg_decoder.hpp
index 6e5a3d4..b5144ab 100644
--- a/include/ast_jpeg_decoder.hpp
+++ b/include/ast_jpeg_decoder.hpp
@@ -6,7 +6,6 @@
 #include <ast_video_types.hpp>
 #include <cassert>
 #include <cstdint>
-#include <g3log/g3log.hpp>
 #include <iostream>
 #include <vector>
 
diff --git a/include/ast_video_puller.hpp b/include/ast_video_puller.hpp
index fd29ca5..6575d7e 100644
--- a/include/ast_video_puller.hpp
+++ b/include/ast_video_puller.hpp
@@ -2,7 +2,6 @@
 
 #include <assert.h>
 #include <ast_video_types.hpp>
-#include <g3log/g3log.hpp>
 #include <iostream>
 #include <mutex>
 #include <vector>
@@ -96,13 +95,13 @@
 
     std::cout << "Write done\n";
     */
-    LOG(DEBUG) << "Reading\n";
+    std::cout << "Reading\n";
     status = read(video_fd, reinterpret_cast<char *>(&image_info),
                   sizeof(image_info));
-    LOG(DEBUG) << "Done reading\n";
+    std::cout << "Done reading\n";
 
     if (status != 0) {
-      LOG(WARNING) << "Read failed with status " << status << "\n";
+      std::cerr << "Read failed with status " << status << "\n";
     }
 
     raw.buffer.resize(image_info.len);
@@ -150,7 +149,7 @@
         dev_video, mutable_buffer, [this](const boost::system::error_code &ec,
                                           std::size_t bytes_transferred) {
           if (ec) {
-            LOG(WARNING) << "Read failed with status " << ec << "\n";
+            std::cerr << "Read failed with status " << ec << "\n";
           } else {
             this->read_done();
           }
@@ -158,7 +157,7 @@
   }
 
   void read_done() {
-    LOG(DEBUG) << "Done reading\n";
+    std::cout << "Done reading\n";
     videobuf->buffer.resize(image_info.len);
 
     videobuf->height = image_info.parameter.features.h;
diff --git a/include/crow/g3_logger.hpp b/include/crow/g3_logger.hpp
index 91e2935..7dfedde 100644
--- a/include/crow/g3_logger.hpp
+++ b/include/crow/g3_logger.hpp
@@ -68,10 +68,10 @@
 #define CROW_LOG_CRITICAL \
   if (!CROW_DISABLE_LOGGING) LOG(FATAL)
 #define CROW_LOG_ERROR \
-  if (!CROW_DISABLE_LOGGING) LOG(WARNING)
+  if (!CROW_DISABLE_LOGGING) std::cerr
 #define CROW_LOG_WARNING \
-  if (!CROW_DISABLE_LOGGING) LOG(WARNING)
+  if (!CROW_DISABLE_LOGGING) std::cerr
 #define CROW_LOG_INFO \
   if (!CROW_DISABLE_LOGGING) LOG(INFO)
 #define CROW_LOG_DEBUG \
-  if (!CROW_DISABLE_LOGGING) LOG(DEBUG)
+  if (!CROW_DISABLE_LOGGING) std::cout
diff --git a/include/ssl_key_handler.hpp b/include/ssl_key_handler.hpp
index aade3fb..4948025 100644
--- a/include/ssl_key_handler.hpp
+++ b/include/ssl_key_handler.hpp
@@ -11,7 +11,6 @@
 #include <openssl/rand.h>
 #include <openssl/rsa.h>
 #include <openssl/ssl.h>
-#include <g3log/g3log.hpp>
 #include <random>
 #include <boost/asio.hpp>
 
@@ -26,7 +25,7 @@
   bool private_key_valid = false;
   bool cert_valid = false;
 
-  LOG(DEBUG) << "Checking certs in file " << filepath;
+  std::cout << "Checking certs in file " << filepath << "\n";
 
   FILE *file = fopen(filepath.c_str(), "r");
   if (file != NULL) {
@@ -35,21 +34,21 @@
     if (pkey) {
       RSA *rsa = EVP_PKEY_get1_RSA(pkey);
       if (rsa) {
-        LOG(DEBUG) << "Found an RSA key";
+        std::cout << "Found an RSA key\n";
         if (RSA_check_key(rsa) == 1) {
           // private_key_valid = true;
         } else {
-          LOG(WARNING) << "Key not valid error number " << ERR_get_error();
+          std::cerr << "Key not valid error number " << ERR_get_error() << "\n";
         }
         RSA_free(rsa);
       } else {
         EC_KEY *ec = EVP_PKEY_get1_EC_KEY(pkey);
         if (ec) {
-          LOG(DEBUG) << "Found an EC key";
+          std::cout << "Found an EC key\n";
           if (EC_KEY_check_key(ec) == 1) {
             private_key_valid = true;
           } else {
-            LOG(WARNING) << "Key not valid error number " << ERR_get_error();
+            std::cerr << "Key not valid error number " << ERR_get_error() << "\n";
           }
           EC_KEY_free(ec);
         }
@@ -58,14 +57,14 @@
       if (private_key_valid) {
         X509 *x509 = PEM_read_X509(file, NULL, NULL, NULL);
         if (!x509) {
-          LOG(DEBUG) << "error getting x509 cert " << ERR_get_error();
+          std::cout << "error getting x509 cert " << ERR_get_error() << "\n";
         } else {
           rc = X509_verify(x509, pkey);
           if (rc == 1) {
             cert_valid = true;
           } else {
-            LOG(WARNING) << "Error in verifying private key signature "
-                         << ERR_get_error();
+            std::cerr << "Error in verifying private key signature "
+                         << ERR_get_error() << "\n";
           }
         }
       }
@@ -79,16 +78,16 @@
 
 inline void generate_ssl_certificate(const std::string &filepath) {
   FILE *pFile = NULL;
-  LOG(WARNING) << "Generating new keys";
+  std::cout << "Generating new keys\n";
   init_openssl();
 
-  // LOG(WARNING) << "Generating RSA key";
+  // std::cerr << "Generating RSA key";
   // EVP_PKEY *pRsaPrivKey = create_rsa_key();
 
-  LOG(WARNING) << "Generating EC key";
+  std::cerr << "Generating EC key\n";
   EVP_PKEY *pRsaPrivKey = create_ec_key();
   if (pRsaPrivKey) {
-    LOG(WARNING) << "Generating x509 Certificate";
+    std::cerr << "Generating x509 Certificate\n";
     // Use this code to directly generate a certificate
     X509 *x509;
     x509 = X509_new();
@@ -221,7 +220,7 @@
   pem_file_valid = verify_openssl_key_cert(filepath);
 
   if (!pem_file_valid) {
-    LOG(WARNING) << "Error in verifying signature, regenerating";
+    std::cerr << "Error in verifying signature, regenerating\n";
     generate_ssl_certificate(filepath);
   }
 }
diff --git a/include/web_kvm.hpp b/include/web_kvm.hpp
index 1671382..3d33347 100644
--- a/include/web_kvm.hpp
+++ b/include/web_kvm.hpp
@@ -205,7 +205,7 @@
                      bool is_binary) {
         switch (meta.vnc_state) {
           case VncState::AWAITING_CLIENT_VERSION: {
-            LOG(DEBUG) << "Client sent: " << data;
+            std::cout << "Client sent: " << data;
             if (data == rfb_3_8_version_string ||
                 data == rfb_3_7_version_string) {
               std::string auth_types{1,
@@ -248,20 +248,20 @@
             server_init_msg.pixel_format.green_shift = 8;
             server_init_msg.pixel_format.blue_shift = 0;
             server_init_msg.name_length = 0;
-            LOG(DEBUG) << "size: " << sizeof(server_init_msg);
+            std::cout << "size: " << sizeof(server_init_msg);
             // TODO(ed) this is ugly.  Crow should really have a span type
             // interface
             // to avoid the copy, but alas, today it does not.
             std::string s(reinterpret_cast<char*>(&server_init_msg),
                           sizeof(server_init_msg));
-            LOG(DEBUG) << "s.size() " << s.size();
+            std::cout << "s.size() " << s.size();
             conn.send_binary(s);
             meta.vnc_state = VncState::MAIN_LOOP;
           } break;
           case VncState::MAIN_LOOP: {
             if (data.size() >= sizeof(client_to_server_msg_type)) {
               auto type = static_cast<client_to_server_msg_type>(data[0]);
-              LOG(DEBUG) << "Received client message type " << (uint32_t)type
+              std::cout << "Received client message type " << (uint32_t)type
                          << "\n";
               switch (type) {
                 case client_to_server_msg_type::set_pixel_format: {
@@ -301,10 +301,10 @@
                     this_rect.height = out.height;
                     this_rect.encoding =
                         static_cast<uint8_t>(encoding_type::raw);
-                    LOG(DEBUG) << "Encoding is " << this_rect.encoding;
+                    std::cout << "Encoding is " << this_rect.encoding;
                     this_rect.data.reserve(this_rect.width * this_rect.height *
                                            4);
-                    LOG(DEBUG) << "Width " << out.width << " Height "
+                    std::cout << "Width " << out.width << " Height "
                                << out.height;
 
                     for (int i = 0; i < out.width * out.height; i++) {
diff --git a/src/token_authorization_middleware_test.cpp b/src/token_authorization_middleware_test.cpp
index 49933c9..e3a18f1 100644
--- a/src/token_authorization_middleware_test.cpp
+++ b/src/token_authorization_middleware_test.cpp
@@ -6,13 +6,7 @@
 using namespace crow;
 using namespace std;
 
-class KnownLoginAuthenticator {
- public:
-  inline bool authenticate(const std::string& username,
-                           const std::string& password) {
-    return (username == "dude") && (password == "foo");
-  }
-};
+
 
 // Tests that static urls are correctly passed
 TEST(TokenAuthentication, TestBasicReject) {
@@ -185,6 +179,15 @@
   app.stop();
 }
 
+// Test class that allows login for a fixed password.
+class KnownLoginAuthenticator {
+ public:
+  inline bool authenticate(const std::string& username,
+                           const std::string& password) {
+    return (username == "dude") && (password == "foo");
+  }
+};
+
 TEST(TokenAuthentication, TestSuccessfulLogin) {
   App<crow::TokenAuthorization<KnownLoginAuthenticator>> app;
   app.bindaddr("127.0.0.1").port(45451);
diff --git a/src/webserver_main.cpp b/src/webserver_main.cpp
index 3baf388..d20b8d5 100644
--- a/src/webserver_main.cpp
+++ b/src/webserver_main.cpp
@@ -20,7 +20,6 @@
 #include "crow/utility.h"
 #include "crow/websocket.h"
 
-#include "color_cout_g3_sink.hpp"
 #include "security_headers_middleware.hpp"
 #include "ssl_key_handler.hpp"
 #include "token_authorization_middleware.hpp"
@@ -42,171 +41,30 @@
 #include <string>
 #include <unordered_set>
 
-using sensor_values = std::vector<std::pair<std::string, int32_t>>;
+static std::shared_ptr<dbus::connection> system_bus;
+static std::shared_ptr<dbus::match> sensor_match;
+static std::shared_ptr<dbus::filter> sensor_filter;
+static std::shared_ptr<dbus::filter> sensor_callback;
 
-sensor_values read_sensor_values() {
-  sensor_values values;
-  DBusError err;
+std::unordered_set<crow::websocket::connection*> users;
 
-  int ret;
-  bool stat;
-  dbus_uint32_t level;
-
-  // initialiset the errors
-  dbus_error_init(&err);
-
-  // connect to the system bus and check for errors
-  DBusConnection* conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
-  if (dbus_error_is_set(&err)) {
-    fprintf(stderr, "Connection Error (%s)\n", err.message);
-    dbus_error_free(&err);
+void on_sensor_update(boost::system::error_code ec, dbus::message s) {
+  std::string object_name;
+  std::vector<std::pair<std::string, dbus::dbus_variant>> values;
+  s.unpack(object_name).unpack(values);
+  crow::json::wvalue j;
+  for (auto& value : values) {
+    //std::cout << "Got sensor value for " << s.get_path() << "\n";
+    boost::apply_visitor([&](auto val) { j[s.get_path()] = val; },
+                         value.second);
   }
-  if (NULL == conn) {
-    exit(1);
+  for (auto conn : users) {
+    conn->send_text(crow::json::dump(j));
   }
-
-  // create a new method call and check for errors
-  DBusMessage* msg = dbus_message_new_method_call(
-      "org.openbmc.Sensors",                  // target for the method call
-      "/org/openbmc/sensors/tach",            // object to call on
-      "org.freedesktop.DBus.Introspectable",  // interface to call on
-      "Introspect");                          // method name
-  if (NULL == msg) {
-    fprintf(stderr, "Message Null\n");
-    exit(1);
-  }
-
-  DBusPendingCall* pending;
-  // send message and get a handle for a reply
-  if (!dbus_connection_send_with_reply(conn, msg, &pending,
-                                       -1)) {  // -1 is default timeout
-    fprintf(stderr, "Out Of Memory!\n");
-    exit(1);
-  }
-  if (NULL == pending) {
-    fprintf(stderr, "Pending Call Null\n");
-    exit(1);
-  }
-  dbus_connection_flush(conn);
-
-  // free message
-  dbus_message_unref(msg);
-
-  // block until we recieve a reply
-  dbus_pending_call_block(pending);
-
-  // get the reply message
-  msg = dbus_pending_call_steal_reply(pending);
-  if (NULL == msg) {
-    fprintf(stderr, "Reply Null\n");
-    exit(1);
-  }
-  // free the pending message handle
-  dbus_pending_call_unref(pending);
-
-  // read the parameters
-  DBusMessageIter args;
-  char* xml_struct = NULL;
-  if (!dbus_message_iter_init(msg, &args)) {
-    fprintf(stderr, "Message has no arguments!\n");
-  }
-
-  // read the arguments
-  if (!dbus_message_iter_init(msg, &args)) {
-    fprintf(stderr, "Message has no arguments!\n");
-  } else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) {
-    fprintf(stderr, "Argument is not string!\n");
-  } else {
-    dbus_message_iter_get_basic(&args, &xml_struct);
-  }
-  std::vector<std::string> methods;
-  if (xml_struct != NULL) {
-    std::string xml_data(xml_struct);
-    std::vector<std::string> names;
-    dbus::read_dbus_xml_names(xml_data, methods);
-  }
-
-  fprintf(stdout, "Found %zd sensors \n", methods.size());
-
-  for (auto& method : methods) {
-    // TODO(Ed) make sure sensor exposes SensorValue interface
-    // create a new method call and check for errors
-    DBusMessage* msg = dbus_message_new_method_call(
-        "org.openbmc.Sensors",  // target for the method call
-        ("/org/openbmc/sensors/tach/" + method).c_str(),  // object to call on
-        "org.openbmc.SensorValue",  // interface to call on
-        "getValue");                // method name
-    if (NULL == msg) {
-      fprintf(stderr, "Message Null\n");
-      exit(1);
-    }
-
-    DBusPendingCall* pending;
-    // send message and get a handle for a reply
-    if (!dbus_connection_send_with_reply(conn, msg, &pending,
-                                         -1)) {  // -1 is default timeout
-      fprintf(stderr, "Out Of Memory!\n");
-      exit(1);
-    }
-    if (NULL == pending) {
-      fprintf(stderr, "Pending Call Null\n");
-      exit(1);
-    }
-    dbus_connection_flush(conn);
-
-    // free message
-    dbus_message_unref(msg);
-
-    // block until we recieve a reply
-    dbus_pending_call_block(pending);
-
-    // get the reply message
-    msg = dbus_pending_call_steal_reply(pending);
-    if (NULL == msg) {
-      fprintf(stderr, "Reply Null\n");
-      exit(1);
-    }
-    // free the pending message handle
-    dbus_pending_call_unref(pending);
-
-    // read the parameters
-    DBusMessageIter args;
-    int32_t value;
-    if (!dbus_message_iter_init(msg, &args)) {
-      fprintf(stderr, "Message has no arguments!\n");
-    }
-
-    // read the arguments
-    if (!dbus_message_iter_init(msg, &args)) {
-      fprintf(stderr, "Message has no arguments!\n");
-    } else if (DBUS_TYPE_VARIANT != dbus_message_iter_get_arg_type(&args)) {
-      fprintf(stderr, "Argument is not string!\n");
-    } else {
-      DBusMessageIter sub;
-      dbus_message_iter_recurse(&args, &sub);
-      auto type = dbus_message_iter_get_arg_type(&sub);
-      if (DBUS_TYPE_INT32 != type) {
-        fprintf(stderr, "Variant subType is not int32 it is %d\n", type);
-      } else {
-        dbus_message_iter_get_basic(&sub, &value);
-        values.emplace_back(method.c_str(), value);
-      }
-    }
-  }
-
-  // free reply and close connection
-  dbus_message_unref(msg);
-  return values;
-}
+  sensor_filter->async_dispatch(on_sensor_update);
+};
 
 int main(int argc, char** argv) {
-  auto worker(g3::LogWorker::createLogWorker());
-  if (false) {
-    auto handle = worker->addDefaultLogger("bmcweb", "/tmp/");
-  }
-  g3::initializeLogging(worker.get());
-  auto sink_handle = worker->addSink(std::make_unique<crow::ColorCoutSink>(),
-                                     &crow::ColorCoutSink::ReceiveLogMessage);
   bool enable_ssl = true;
   std::string ssl_pem_file("server.pem");
 
@@ -249,32 +107,53 @@
   CROW_ROUTE(app, "/sensorws")
       .websocket()
       .onopen([&](crow::websocket::connection& conn) {
-        dbus::connection system_bus(conn.get_io_service(), dbus::bus::system);
-        dbus::match ma(system_bus,
-                       "type='signal',sender='org.freedesktop.DBus', "
-                       "interface='org.freedesktop.DBus.Properties',member="
-                       "'PropertiesChanged'");
-        dbus::filter f(system_bus, [](dbus::message& m) { return true; });
+        system_bus = std::make_shared<dbus::connection>(conn.get_io_service(),
+                                                        dbus::bus::system);
+        sensor_match = std::make_shared<dbus::match>(
+            *system_bus,
+            "type='signal',path_namespace='/xyz/openbmc_project/sensors'");
 
-        f.async_dispatch([&](boost::system::error_code ec, dbus::message s) {
-          std::cout << "got event\n";
-          //f.async_dispatch(event_handler);
-        });
-
+        sensor_filter =
+            std::make_shared<dbus::filter>(*system_bus, [](dbus::message& m) {
+              auto member = m.get_member();
+              return member == "PropertiesChanged";
+            });
+        /*
+        std::function<void(boost::system::error_code, dbus::message)>
+            sensor_callback = [&conn, sensor_callback](
+                boost::system::error_code ec, dbus::message s) {
+              std::string object_name;
+              std::vector<std::pair<std::string, dbus::dbus_variant>> values;
+              s.unpack(object_name).unpack(values);
+              crow::json::wvalue j;
+              for (auto& value : values) {
+                std::cout << "Got sensor value for " << s.get_path() << "\n";
+                boost::apply_visitor([&](auto val) { j[s.get_path()] = val; },
+                                     value.second);
+              }
+              for (auto conn : users) {
+                conn.send_text(crow::json::dump(j));
+              }
+              sensor_filter->async_dispatch(sensor_callback);
+            };
+            */
+        sensor_filter->async_dispatch(on_sensor_update);
+        users.insert(&conn);
+        ;
       })
       .onclose(
           [&](crow::websocket::connection& conn, const std::string& reason) {
-
+            // TODO(ed) needs lock
+            users.erase(&conn);
           })
       .onmessage([&](crow::websocket::connection& conn, const std::string& data,
                      bool is_binary) {
-
+        CROW_LOG_ERROR << "Got unexpected message from client on sensorws";
       });
 
   CROW_ROUTE(app, "/sensortest")
   ([](const crow::request& req, crow::response& res) {
     crow::json::wvalue j;
-    auto values = read_sensor_values();
 
     dbus::connection system_bus(*req.io_service, dbus::bus::system);
     dbus::endpoint test_daemon("org.openbmc.Sensors",
@@ -294,7 +173,7 @@
                                        "/org/openbmc/sensors/tach/" + object,
                                        "org.openbmc.SensorValue");
             dbus::message m2 = dbus::message::new_call(test_daemon, "getValue");
-            
+
             system_bus.async_send(
                 m2, [&](const boost::system::error_code ec, dbus::message r) {
                   int32_t value;
@@ -311,9 +190,9 @@
   CROW_ROUTE(app, "/intel/firmwareupload")
       .methods("POST"_method)([](const crow::request& req) {
         // TODO(ed) handle errors here (file exists already and is locked, ect)
-        std::ofstream out("/tmp/fw_update_image", std::ofstream::out |
-                                                      std::ofstream::binary |
-                                                      std::ofstream::trunc);
+        std::ofstream out(
+            "/tmp/fw_update_image",
+            std::ofstream::out | std::ofstream::binary | std::ofstream::trunc);
         out << req.body;
         out.close();
 
@@ -323,17 +202,17 @@
         return j;
       });
 
-  LOG(DEBUG) << "Building SSL context";
+  std::cout << "Building SSL context\n";
 
   int port = 18080;
 
-  LOG(DEBUG) << "Starting webserver on port " << port;
+  std::cout << "Starting webserver on port " << port << "\n";
   app.port(port);
   if (enable_ssl) {
-    LOG(DEBUG) << "SSL Enabled";
+    std::cout << "SSL Enabled\n";
     auto ssl_context = ensuressl::get_ssl_context(ssl_pem_file);
     app.ssl(std::move(ssl_context));
   }
-  //app.concurrency(4);
+  // app.concurrency(4);
   app.run();
 }
diff --git a/static/js/sensorController.js b/static/js/sensorController.js
index f1e0812..67c9d82 100644
--- a/static/js/sensorController.js
+++ b/static/js/sensorController.js
@@ -1,8 +1,41 @@
 angular.module('bmcApp').controller('sensorController', [
-  '$scope', '$http',
-  function($scope, $http) {
-    $http.get('/sensortest').then(function(sensor_values) {
-      $scope.sensor_values = sensor_values;
-    })
+  '$scope', '$http', '$location', 'websocketService',
+  function($scope, $http, $location, websocketService) {
+    $scope.sensor_values = {};
+
+    var host = $location.host();
+    var port = $location.port();
+    var protocol = "ws://";
+    if ($location.protocol() === 'https') {
+      protocol = 'wss://';
+    }
+    websocketService.start(protocol + host + ":" + port + "/sensorws", function (evt) {
+        var obj = JSON.parse(evt.data);
+        $scope.$apply(function () {
+            for (var key in obj) {
+              if (obj.hasOwnProperty(key)) {
+                console.log(key + " -> " + obj[key]);
+                $scope.sensor_values[key] = obj[key];
+              }
+            }
+        });
+    });
+
   }
-]);
\ No newline at end of file
+]);
+
+app.factory('websocketService', function () {
+        return {
+            start: function (url, callback) {
+                var websocket = new WebSocket(url);
+                websocket.onopen = function () {
+                };
+                websocket.onclose = function () {
+                };
+                websocket.onmessage = function (evt) {
+                    callback(evt);
+                };
+            }
+        }
+    }
+);
\ No newline at end of file