diff --git a/.gitignore b/.gitignore
index eff1885..a7bb153 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,4 @@ dist/
 CarTracker
 cartracker.yml
 *.creds
+utils/gpsrecorder/gpsrecorder
diff --git a/go.mod b/go.mod
index b962d03..0a4c3b9 100644
--- a/go.mod
+++ b/go.mod
@@ -3,18 +3,27 @@ module github.com/Fishwaldo/CarTracker
 go 1.16
 
 require (
-	github.com/Fishwaldo/go-dcdc200 v0.0.2-0.20210923120656-7b609977be06
+	github.com/Fishwaldo/go-dcdc200 v0.0.5
 	github.com/Fishwaldo/go-logadapter v0.0.2
-	github.com/Fishwaldo/go-taskmanager v0.0.0-20210918045401-1ed25dc708fa
+	github.com/Fishwaldo/go-taskmanager v0.0.1
 	github.com/adrianmo/go-nmea v1.7.0
 	github.com/blang/semver/v4 v4.0.0
+	github.com/bombsimon/logrusr/v2 v2.0.1
+	github.com/go-logr/logr v1.2.3 // indirect
 	github.com/godbus/dbus/v5 v5.1.0
 	github.com/jacobsa/go-serial v0.0.0-20180131005756-15cf729a72d4
 	github.com/labstack/echo/v4 v4.7.2
+	github.com/m3db/prometheus_client_golang v0.8.1 // indirect
+	github.com/m3db/prometheus_client_model v0.1.0 // indirect
+	github.com/m3db/prometheus_common v0.1.0 // indirect
+	github.com/m3db/prometheus_procfs v0.8.1 // indirect
 	github.com/nats-io/nats-server/v2 v2.6.1 // indirect
 	github.com/nats-io/nats.go v1.13.0
 	github.com/sasha-s/go-deadlock v0.3.1
 	github.com/shirou/gopsutil/v3 v3.22.3
+	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/viper v1.10.1
+	github.com/uber-go/tally v3.3.17+incompatible // indirect
+	go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee // indirect
 	golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f
 )
diff --git a/go.sum b/go.sum
index 15bbd32..132de06 100644
--- a/go.sum
+++ b/go.sum
@@ -48,12 +48,14 @@ dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
-github.com/Fishwaldo/go-dcdc200 v0.0.2-0.20210923120656-7b609977be06 h1:8YRr71BDH+YqEtU/zCSQqKn1yZZEadgvfrkth9Cx4rE=
-github.com/Fishwaldo/go-dcdc200 v0.0.2-0.20210923120656-7b609977be06/go.mod h1:nWjbjLhUOHi5zVsFDVkUK3Zq0Nzkb8gZXavrbev/aN4=
+github.com/Fishwaldo/go-dcdc200 v0.0.5 h1:lj8lcXk8AFzCuLK2DQ7jrfEpykvyh9RKYLL52cuNY/Y=
+github.com/Fishwaldo/go-dcdc200 v0.0.5/go.mod h1:vvmZK1o2Vflot5kyAMsxAP/IPNo8W1CjNArkJ2IxgHs=
 github.com/Fishwaldo/go-logadapter v0.0.2 h1:RxFOr+bEDqQ1rPUmjUX5u8fGLCKY0Lyea+9AxDqzaW4=
 github.com/Fishwaldo/go-logadapter v0.0.2/go.mod h1:aRbQ8rWdpeD0WWo241ctqgk/yRto8Axg09EkwWiVGK0=
 github.com/Fishwaldo/go-taskmanager v0.0.0-20210918045401-1ed25dc708fa h1:jmdvyf//bVNvLtdN+WZzLb6NiNrpgTpXZvhOzLHIXmU=
 github.com/Fishwaldo/go-taskmanager v0.0.0-20210918045401-1ed25dc708fa/go.mod h1:dB2gqoUS+kaNVtdXYDKfCE05Pu4+p2N002OB4s79h7s=
+github.com/Fishwaldo/go-taskmanager v0.0.1 h1:ZAHZYVfy1VRZm69VvGjHWeCaVKHHez2gqzqH6UVxJpQ=
+github.com/Fishwaldo/go-taskmanager v0.0.1/go.mod h1:Dw/Fi6TnbYFRKpjyylny5VhGMPavgaZiAnU+N5RiGM4=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/adrianmo/go-nmea v1.7.0 h1:ji8IeiuUG+LTpVoUxmLPHr/WuxFvvD2S6lYDfDze5yw=
 github.com/adrianmo/go-nmea v1.7.0/go.mod h1:u8bPnpKt/D/5rll/5l9f6iDfeq5WZW0+/SXdkwix6Tg=
@@ -76,6 +78,8 @@ github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6r
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
 github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
+github.com/bombsimon/logrusr/v2 v2.0.1 h1:1VgxVNQMCvjirZIYaT9JYn6sAVGVEcNtRE0y4mvaOAM=
+github.com/bombsimon/logrusr/v2 v2.0.1/go.mod h1:ByVAX+vHdLGAfdroiMg6q0zgq2FODY2lc5YJvzmOJio=
 github.com/cenkalti/backoff/v4 v4.1.0/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
@@ -100,6 +104,7 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH
 github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -127,6 +132,12 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logr/logr v1.0.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
+github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
@@ -187,8 +198,8 @@ github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
 github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/gousb v1.1.1 h1:2sjwXlc0PIBgDnXtNxUrHcD/RRFOmAtRq4QgnFBE6xc=
-github.com/google/gousb v1.1.1/go.mod h1:b3uU8itc6dHElt063KJobuVtcKHWEfFOysOqBNzHhLY=
+github.com/google/gousb v2.1.0+incompatible h1:ApzMDjF3FeO219QwWybJxYfFhXQzPLOEy0o+w9k5DNI=
+github.com/google/gousb v2.1.0+incompatible/go.mod h1:Tl4HdAs1ThE3gECkNwz+1MWicX6FXddhJEw7L8jRDiI=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
 github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
@@ -266,14 +277,17 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/klauspost/compress v1.13.4 h1:0zhec2I8zGnjWcKyLl6i3gPqKANCCn5e9xmviEEeX6s=
 github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
 github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/labstack/echo/v4 v4.7.2 h1:Kv2/p8OaQ+M6Ex4eGimg9b9e6icoxA42JSlOR3msKtI=
 github.com/labstack/echo/v4 v4.7.2/go.mod h1:xkCDAdFCIf8jsFQ5NnbK7oqaF/yU1A1X20Ltm0OvSks=
 github.com/labstack/gommon v0.3.1 h1:OomWaJXm7xR6L1HmEtGyQf26TEn7V6X88mktX9kee9o=
@@ -611,6 +625,7 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210608053332-aa57babbf139/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -849,8 +864,9 @@ google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/ini.v1 v1.66.2 h1:XfR1dOYubytKy4Shzc2LHrrGhU0lDCfDGG1yLPmpgsI=
 gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
diff --git a/internal/dbus/dbus.go b/internal/dbus/dbus.go
index 47f6c60..77fd2ab 100644
--- a/internal/dbus/dbus.go
+++ b/internal/dbus/dbus.go
@@ -3,38 +3,70 @@ package dbus
 //dbus-send --system --type=method_call --dest=org.freedesktop.login1 /org/freedesktop/login1 org.freedesktop.login1.Manager.ScheduleShutdown string:"reboot" uint64:1632282493000000
 
 import (
-	"fmt"
-	"os"
 
-	"github.com/Fishwaldo/go-logadapter"
+	//	"time"
+	"time"
+
+	dcdcusb "github.com/Fishwaldo/go-dcdc200"
+	"github.com/sasha-s/go-deadlock"
+	"github.com/go-logr/logr"
 	"github.com/godbus/dbus/v5"
 )
 
 type DbusS struct {
+	log      logr.Logger
+	mx       deadlock.RWMutex
+	conn     *dbus.Conn
+	curstate dcdcusb.DcdcStatet
 }
 
-var DBUS DbusS
+var DBUS *DbusS
 
-func (d DbusS) Start(logadapter.Logger) {
+func (d *DbusS) Start(log logr.Logger) {
+	d = &DbusS{}
+	d.log = log
 	var list []string
-	conn, err := dbus.SystemBus()
+	var err error
+	d.conn, err = dbus.SystemBus()
 	if err != nil {
-		panic(err)
+		d.log.Error(err, "Dbus Connection Error")
 	}
 
-	err = conn.BusObject().Call("org.freedesktop.DBus.ListNames", 0).Store(&list)
+	err = d.conn.BusObject().Call("org.freedesktop.DBus.ListNames", 0).Store(&list)
 	if err != nil {
-		panic(err)
+		d.log.Error(err, "Dbus Call Error")
 	}
 	for _, v := range list {
-		fmt.Println(v)
+		d.log.Info("Info: ", "list", v)
 	}
-	var s string
-	err = conn.Object("org.freedesktop.login1", "/").Call("org.freedesktop.DBus.Introspectable.Introspect", 0).Store(&s)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "Failed to introspect bluez", err)
-		os.Exit(1)
-	}
-
-	fmt.Println(s)
+	DBUS = d
+}
+
+func (d *DbusS) ProcessPowerSupply(param dcdcusb.Params) error {
+	d.mx.Lock()
+	defer d.mx.Unlock()
+	if d.curstate != param.State {
+		d.log.Info("Power State Transition", "state", param.State)
+		d.curstate = param.State
+		if d.curstate == dcdcusb.StateIgnOff {
+			d.log.Info("Ignition Powered Off - Scheduling Shutdown")
+		}
+	}
+	if d.curstate == dcdcusb.StateIgnOff {
+		if param.State == dcdcusb.StateOk {
+			d.log.Info("Ignition On - Canceling Shutdown")
+			d.curstate = param.State
+		} else {
+			d.log.Info("Shutdown in", "timeout", param.TimerSoftOff.Seconds())
+			if param.TimerSoftOff.Seconds() < 60 {
+				when := time.Now().Add(time.Minute)
+				d.log.Info("Shutdown at ", "when", when.String())
+				call := d.conn.Object("org.freedesktop.login1", "/org/freedesktop/login1").Call("org.freedesktop.login1.Manager.ScheduleShutdown", 0, "dry-poweroff", uint64(when.UnixMicro()))
+				if call.Err != nil {
+					d.log.Error(call.Err, "Failed to Schedule Shutdown")
+				}			
+			}
+		}
+	}
+	return nil
 }
diff --git a/internal/gps/gps.go b/internal/gps/gps.go
index fc092e0..233a238 100644
--- a/internal/gps/gps.go
+++ b/internal/gps/gps.go
@@ -7,9 +7,8 @@ import (
 	"time"
 
 	"github.com/Fishwaldo/CarTracker/internal"
-	"github.com/Fishwaldo/CarTracker/internal/natsconnection"
 	tm "github.com/Fishwaldo/CarTracker/internal/taskmanager"
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/Fishwaldo/go-taskmanager"
 	"github.com/adrianmo/go-nmea"
 	"github.com/jacobsa/go-serial/serial"
@@ -36,7 +35,7 @@ type GPSData struct {
 }
 
 type GpsS struct {
-	logger  logadapter.Logger
+	logger  logr.Logger
 	serial  io.ReadWriteCloser
 	scanner *bufio.Scanner
 	Data    GPSData
@@ -45,7 +44,7 @@ type GpsS struct {
 
 var GPS GpsS
 
-func (g *GpsS) Start(log logadapter.Logger) {
+func (g *GpsS) Start(log logr.Logger) {
 	g.stop = make(chan interface{})
 	g.logger = log
 	options := serial.OpenOptions{
@@ -57,18 +56,18 @@ func (g *GpsS) Start(log logadapter.Logger) {
 	}
 	var err error
 	if g.serial, err = serial.Open(options); err != nil {
-		g.logger.Warn("Can't Open GPS Serial Port: %s", err)
+		g.logger.Error(err, "Can't Open GPS Serial Port")
 	}
 	g.scanner = bufio.NewScanner(bufio.NewReader(g.serial))
 	go g.Scan()
 
 	fixedTimer, err := taskmanager.NewFixed(viper.GetDuration("gps.poll") * time.Second)
 	if err != nil {
-		g.logger.Panic("invalid interval: %s", err.Error())
+		g.logger.Error(err, "invalid interval")
 	}
 	err = tm.GetScheduler().Add(context.Background(), "GPS", fixedTimer, g.Poll)
 	if err != nil {
-		g.logger.Panic("Can't Initilize Scheduler for GPS: %s", err)
+		g.logger.Error(err, "Can't Initilize Scheduler for GPS")
 	}
 	g.logger.Info("Added GPS Polling Schedule")
 
@@ -82,10 +81,10 @@ func (g *GpsS) Scan() {
 			return
 		default:
 			scanText := g.scanner.Text()
-			g.logger.Trace("Scanning... %s", scanText)
+			g.logger.V(1).Info("Scanning... ", "data", scanText)
 			s, err := nmea.Parse(scanText)
 			if err == nil {
-				g.logger.Trace("Got NMEA Type: %s", s.DataType())
+				g.logger.V(1).Info("Got NMEA Type", "type", s.DataType())
 				switch s.DataType() {
 				case nmea.TypeRMC:
 					data := s.(nmea.RMC)
@@ -93,7 +92,7 @@ func (g *GpsS) Scan() {
 					g.Data.Latitude = data.Latitude
 					g.Data.Longitude = data.Longitude
 					g.Data.mx.Unlock()
-					g.logger.Trace("RMC Lat: %0.4f Long: %0.4f", data.Latitude, data.Longitude)
+					g.logger.V(1).Info("RMC Data", "lat", data.Latitude, "long", data.Longitude)
 
 				case nmea.TypeGGA:
 					data := s.(nmea.GGA)
@@ -102,17 +101,17 @@ func (g *GpsS) Scan() {
 					g.Data.HDOP = data.HDOP
 					g.Data.NumSatellites = data.NumSatellites
 					g.Data.mx.Unlock()
-					g.logger.Trace("GAA Altitide: %0.2f HDOP: %0.2f Satellites: %d", data.Altitude, data.HDOP, data.NumSatellites)
+					g.logger.V(1).Info("GAA Data", "altitide", data.Altitude, "hdop", data.HDOP, "satellites", data.NumSatellites)
 				case nmea.TypeVTG:
 					data := s.(nmea.VTG)
 					g.Data.mx.Lock()
 					g.Data.Track = data.TrueTrack
 					g.Data.Speed = data.GroundSpeedKPH
 					g.Data.mx.Unlock()
-					g.logger.Trace("VTG Track: %0.2f Speed: %0.2f", data.TrueTrack, data.GroundSpeedKPH)
+					g.logger.V(1).Info("VTG Data", "track", data.TrueTrack, "speed", data.GroundSpeedKPH)
 				}
 			} else {
-				g.logger.Warn("GPS Read Failed: %s\n%s", err, scanText)
+				g.logger.Error(err, "GPS Read Failed", "scantext", scanText)
 			}
 		}
 	}
@@ -126,6 +125,6 @@ func (g *GpsS) Stop() {
 
 func (g *GpsS) Poll(ctx context.Context) {
 	g.Data.mx.RLock()
-	natsconnection.Nats.SendStats("gps", &g.Data)
+	internal.ProcessUpdate("gps", &g.Data)
 	g.Data.mx.RUnlock()
 }
diff --git a/internal/natsconnection/natsconnection.go b/internal/natsconnection/natsconnection.go
index 0cdd884..e3a2ff2 100644
--- a/internal/natsconnection/natsconnection.go
+++ b/internal/natsconnection/natsconnection.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"time"
 
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/nats-io/nats.go"
 	"github.com/sasha-s/go-deadlock"
 	"github.com/spf13/viper"
@@ -22,7 +22,7 @@ type NatsConnS struct {
 	conn *nats.Conn
 	enc *nats.EncodedConn
 	js nats.JetStreamContext
-	logger logadapter.Logger
+	logger logr.Logger
 	inCMDSubject string
 	inCmdSubscription *nats.Subscription
 	outCMDPrefix string
@@ -31,7 +31,7 @@ type NatsConnS struct {
 
 var Nats NatsConnS
 
-func (nc *NatsConnS) Start(log logadapter.Logger) {
+func (nc *NatsConnS) Start(log logr.Logger) {
 	nc.logger = log
 
 	url := fmt.Sprintf("%s:%d", viper.GetString("nats.host"), viper.GetInt("nats.port"))
@@ -39,7 +39,7 @@ func (nc *NatsConnS) Start(log logadapter.Logger) {
 	var options []nats.Option
 
 	if _, err := os.Stat(viper.GetString("nats.credfile")); os.IsNotExist(err) {
-		nc.logger.Warn("Credential File Does not Exsist")
+		nc.logger.Error(err, "Credential File Does not Exist")
 	} else {
 		options = append(options, nats.UserCredentials(viper.GetString("nats.credfile")))
 	}
@@ -51,38 +51,38 @@ func (nc *NatsConnS) Start(log logadapter.Logger) {
 	options = append(options, nats.ReconnectBufSize(64*1024*1024))
 
 	if nc.conn, err = nats.Connect(url, options...); err != nil {
-		nc.logger.Warn("Can't Connect to NATS Server: %s", err)
+		nc.logger.Error(err, "Can't Connect to NATS Server")
 	}
-	nc.logger.Info("Connected to NATS Server: %s (Cluster: %s)", nc.conn.ConnectedServerName(), nc.conn.ConnectedClusterName())
+	nc.logger.Info("Connected to NATS Server", "name", nc.conn.ConnectedServerName(), "cluster", nc.conn.ConnectedClusterName())
 	if nc.enc, err = nats.NewEncodedConn(nc.conn, "json"); err != nil {
-		nc.logger.Warn("Can't Create Encoded Connection: %s", err)
+		nc.logger.Error(err, "Can't Create Encoded Connection")
 	}
 
 	if nc.js, err = nc.conn.JetStream(); err != nil {
-		nc.logger.Warn("Can't Create JetStream Context: %s", err)
+		nc.logger.Error(err, "Can't Create JetStream Context")
 	}
 
 	nc.inCMDSubject = fmt.Sprintf("cmd.car.%s", viper.GetString("name"))
 	nc.outCMDPrefix = fmt.Sprintf("report.car.%s", viper.GetString("name"))
 	if nc.inCmdSubscription, err = nc.enc.Subscribe(nc.inCMDSubject, nc.gotMessage); err != nil {
-		nc.logger.Warn("Can't Subscribe to %s subject: %s", nc.inCMDSubject, err)
+		nc.logger.Error(err, "Can't Subscribe to subject", "subject", nc.inCMDSubject)
 	}
 	if err = nc.enc.Publish(nc.inCMDSubject, string("test hello")); err != nil {
-		nc.logger.Warn("Can't Publish to %s subject: %s", nc.inCMDSubject, err)
+		nc.logger.Error(err, "Can't Publish to subject", "subject", nc.inCMDSubject)
 	}
 
 	nc.conn.Flush()
 }
 
 func (nc *NatsConnS) gotMessage(m *nats.Msg) {
-	nc.logger.Info("Got Message from Subject `%s`: %s", m.Subject, m.Data)
+	nc.logger.Info("Got Message from Subject", "subject", m.Subject, "data", m.Data)
 }
 
 func (nc *NatsConnS) serverDisconnect(c *nats.Conn, err error) {
-	nc.logger.Warn("Nats Server Disconnected: %s", err)
+	nc.logger.Error(err, "Nats Server Disconnected")
 }
 func (nc *NatsConnS) serverReconnected(c *nats.Conn) {
-	nc.logger.Info("Nats Server Reconnected %s (Cluster %s)", nc.conn.ConnectedServerName(), nc.conn.ConnectedClusterName())
+	nc.logger.Info("Nats Server Reconnected", "name", nc.conn.ConnectedServerName(), "cluster", nc.conn.ConnectedClusterName())
 }
 
 func (nc *NatsConnS) SendStats(domain string, ps interface{}) {
@@ -92,7 +92,7 @@ func (nc *NatsConnS) SendStats(domain string, ps interface{}) {
 	msg.Header.Add("X-Msg-Time", time.Now().Format(time.RFC3339))
 	msg.Data, _ = json.Marshal(ps)
 	if _, err := nc.js.PublishMsg(msg); err != nil {
-		nc.logger.Warn("Can't Publish %s Messages: %s", domain, err)
+		nc.logger.Error(err, "Can't Publish Messages", "domain", domain)
 	}
 }
 
diff --git a/internal/perf/perf.go b/internal/perf/perf.go
index 3818821..e5f20a3 100644
--- a/internal/perf/perf.go
+++ b/internal/perf/perf.go
@@ -6,11 +6,10 @@ import (
 
 	"net/http"
 
-	"github.com/Fishwaldo/CarTracker/internal/natsconnection"
 	"github.com/Fishwaldo/CarTracker/internal"
 	tm "github.com/Fishwaldo/CarTracker/internal/taskmanager"
 	"github.com/Fishwaldo/CarTracker/internal/web"
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/Fishwaldo/go-taskmanager"
 	"github.com/labstack/echo/v4"
 	"github.com/sasha-s/go-deadlock"
@@ -49,25 +48,25 @@ type PerfStats struct {
 
 type PerfS struct {
 	Performance PerfStats
-	log         logadapter.Logger
+	log         logr.Logger
 	mx          deadlock.RWMutex
 }
 
 var Perf PerfS
 
-func (p *PerfS) Start(log logadapter.Logger) {
+func (p *PerfS) Start(log logr.Logger) {
 	p.log = log
 	var err error
 	ctx, _ := context.WithTimeout(context.Background(), viper.GetDuration("perf.timeout") *time.Second)
 
 	if p.Performance.Cpuinfo, err = cpu.InfoWithContext(ctx); err != nil {
-		p.log.Warn("Can't Get CPU Info: %w", err)
+		p.log.Error(err, "Can't Get CPU Info")
 	}
 	if p.Performance.Diskpartions, err = disk.PartitionsWithContext(ctx, true); err != nil {
-		p.log.Warn("Can't Get Disk Partitions: %w", err)
+		p.log.Error(err, "Can't Get Disk Partitions")
 	}
 	if p.Performance.Hostinfo, err = host.InfoWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Host Info: %w", err)
+		p.log.Error(err, "Can't get Host Info")
 	}
 	p.Poll(ctx)
 
@@ -88,11 +87,11 @@ func (p *PerfS) Start(log logadapter.Logger) {
 
 	fixedTimer1second, err := taskmanager.NewFixed(viper.GetDuration("perf.poll") * time.Second)
 	if err != nil {
-		p.log.Panic("invalid interval: %s", err.Error())
+		p.log.Error(err, "invalid interval")
 	}
 	err = tm.GetScheduler().Add(context.Background(), "Perf", fixedTimer1second, p.Poll)
 	if err != nil {
-		p.log.Panic("Can't Initilize Scheduler for Perf: %s", err)
+		p.log.Error(err, "Can't Initilize Scheduler for Perf")
 	}
 	p.log.Info("Added Perf Polling Schedule")
 }
@@ -110,41 +109,40 @@ func (p *PerfS) Poll(ctx context.Context) {
 	ctx, cancel := context.WithTimeout(ctx, viper.GetDuration("perf.timeout") * time.Second)
 	defer cancel()
 	if p.Performance.Cputime, err = cpu.TimesWithContext(ctx, true); err != nil {
-		p.log.Warn("Can't get CPU Time: %w", err)
+		p.log.Error(err, "Can't get CPU Time")
 	}
 	if p.Performance.Cpuutilization, err = cpu.PercentWithContext(ctx, 1*time.Second, true); err != nil {
-		p.log.Warn("Can't Get CPU Load: %w", err)
+		p.log.Error(err, "Can't Get CPU Load")
 	}
 	if p.Performance.Diskiocounter, err = disk.IOCountersWithContext(ctx); err != nil {
-		p.log.Warn("Cant get IO Stats: %w", err)
+		p.log.Error(err, "Cant get IO Stats")
 	}
 	if p.Performance.Hosttemp, err = host.SensorsTemperaturesWithContext(ctx); err != nil {
-		p.log.Warn("Can't Get Temp Stats: %w", err)
+		p.log.Error(err, "Can't Get Temp Stats")
 	}
 	if p.Performance.Hostusers, err = host.UsersWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Users: %w", err)
+		p.log.Error(err, "Can't get Users")
 	}
 	if p.Performance.Loadavg, err = load.AvgWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Load Average: %w", err)
+		p.log.Error(err, "Can't get Load Average")
 	}
 	if p.Performance.Loadprocs, err = load.MiscWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Proc Info: %w", err)
+		p.log.Error(err, "Can't get Proc Info")
 	}
 	if p.Performance.Memstats, err = mem.VirtualMemoryWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Memory Stats: %w", err)
+		p.log.Error(err, "Can't get Memory Stats")
 	}
 	if p.Performance.Memswap, err = mem.SwapMemoryWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Swap Stats: %w", err)
+		p.log.Error(err, "Can't get Swap Stats")
 	}
 	if p.Performance.Netstats, err = net.IOCountersWithContext(ctx, true); err != nil {
-		p.log.Warn("Can't get Network IO Stats: %w", err)
+		p.log.Error(err, "Can't get Network IO Stats")
 	}
 	if p.Performance.Netaddr, err = net.InterfacesWithContext(ctx); err != nil {
-		p.log.Warn("Can't get Interface Info")
+		p.log.Error(err, "Can't get Interface Info")
 	}
-	natsconnection.Nats.SendStats("Perf", p.Performance)
 
-	//p.log.Info("Perf: %+v", p.Performance)
+	internal.ProcessUpdate("Perf", p.Performance)
 }
 
 func (p *PerfS) CPUInfo(c echo.Context) error {
diff --git a/internal/plugin.go b/internal/plugin.go
index 3eea37e..e3cc3e7 100644
--- a/internal/plugin.go
+++ b/internal/plugin.go
@@ -2,11 +2,33 @@ package internal
 
 import (
 	"context"
-	"github.com/Fishwaldo/go-logadapter"
+	"encoding/json"
+	"time"
+
+	"github.com/Fishwaldo/CarTracker/internal/dbus"
+	"github.com/Fishwaldo/CarTracker/internal/natsconnection"
+	"github.com/Fishwaldo/CarTracker/internal/web"
+	tm "github.com/Fishwaldo/CarTracker/internal/taskmanager"
+	"github.com/Fishwaldo/go-taskmanager"
+	dcdcusb "github.com/Fishwaldo/go-dcdc200"
+	"github.com/go-logr/logr"
 )
+type power struct {
+	Vin float32
+	Vout float32
+	PowerOn bool
+	ShutDownTimeout time.Duration	
+}
+
+type StatusMsg struct { 
+	Power power
+}
+
+var State StatusMsg
+
 
 type PluginI interface {
-	Start(logadapter.Logger)
+	Start(logr.Logger)
 	Stop()
 	Poll(context.Context)
 }
@@ -17,7 +39,7 @@ func init() {
 	Plugins = make(map[string]PluginI)
 }
 
-var log logadapter.Logger
+var log logr.Logger
 
 func RegisterPlugin(name string, pi PluginI) {
 	_, ok := Plugins[name]; 
@@ -27,17 +49,56 @@ func RegisterPlugin(name string, pi PluginI) {
 	Plugins[name] = pi
 }
 
-func StartPlugins(logger logadapter.Logger) {
+func StartPlugins(logger logr.Logger) {
 	log = logger
 	for name, pi := range Plugins {
-		log.Info("Starting Plugin %s", name)
-		pi.Start(log.New(name))
+		log.Info("Starting Plugin", "plugin", name)
+		pi.Start(log.WithName(name))
 	}
 }
 
 func StopPlugins() {
 	for name, pi := range Plugins {
-		log.Info("Stopping Plugin %s", name)
+		log.Info("Stopping Plugin", "plugin", name)
 		pi.Stop()
 	}
+}
+
+func ProcessUpdate(plugin string, data interface{}) error {
+	natsconnection.Nats.SendStats(plugin, data)
+
+	switch msg := data.(type) {
+	case dcdcusb.Params:
+		dbus.DBUS.ProcessPowerSupply(msg)
+		State.Power.Vin = msg.Vin
+		State.Power.Vout = msg.VoutActual
+		if msg.State == dcdcusb.StateOk {
+			State.Power.PowerOn = true
+		} else { 
+			State.Power.PowerOn = false
+		}
+	}
+	return nil;
+}
+
+func InitStatusUpdate() {
+	fixedTimer1second, err := taskmanager.NewFixed(1 * time.Second)
+	if err != nil {
+		log.Error(err, "invalid interval")
+	}
+
+	err = tm.GetScheduler().Add(context.TODO(), "StatusBroadcast", fixedTimer1second, SendPeriodUpdate)
+	if err != nil {
+		log.Error(err, "Can't Initilize Scheduler for StatusBroadcast")
+	}
+	log.Info("Initilized Scheduler for StatusBroadcast")
+}
+
+func SendPeriodUpdate(ctx context.Context) {
+	log.Info("Sending Status Update")
+	if txt, err := json.Marshal(State); err != nil {
+		log.Error(err, "Error marshalling state")
+	} else {
+		web.Web.Broadcast(string(txt))
+	}
 }
\ No newline at end of file
diff --git a/internal/powersupply/powersupply.go b/internal/powersupply/powersupply.go
index 23a3376..2de34d6 100644
--- a/internal/powersupply/powersupply.go
+++ b/internal/powersupply/powersupply.go
@@ -7,11 +7,10 @@ import (
 	"net/http"
 
 	"github.com/Fishwaldo/CarTracker/internal"
-	"github.com/Fishwaldo/CarTracker/internal/natsconnection"
 	tm "github.com/Fishwaldo/CarTracker/internal/taskmanager"
 	"github.com/Fishwaldo/CarTracker/internal/web"
 	dcdcusb "github.com/Fishwaldo/go-dcdc200"
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/Fishwaldo/go-taskmanager"
 	"github.com/labstack/echo/v4"
 	"github.com/sasha-s/go-deadlock"
@@ -20,6 +19,7 @@ import (
 
 func init() {
 	viper.SetDefault("powersupply.poll", 5)
+	viper.SetDefault("powersupply.sim", true)
 	internal.RegisterPlugin("powersupply", &PowerSupply)
 }
 
@@ -27,26 +27,33 @@ type PowerSupplyS struct {
 	PowerSupply dcdcusb.DcDcUSB
 	ok          bool
 	Params      dcdcusb.Params
-	log         logadapter.Logger
+	log         logr.Logger
 	mx          deadlock.RWMutex
 }
 
 var PowerSupply PowerSupplyS
 
-func (PS *PowerSupplyS) Start(log logadapter.Logger) {
+func (PS *PowerSupplyS) Start(log logr.Logger) {
 	PS.mx.Lock()
 	defer PS.mx.Unlock()
 	PS.log = log
 	PS.PowerSupply = dcdcusb.DcDcUSB{}
-	PS.PowerSupply.SetLogger(PS.log)
-	PS.PowerSupply.Init()
+	//PS.PowerSupply.SetLogger(PS.log)
+	if viper.GetBool("powersupply.sim") {
+//		if err := dcdcusbsim.SetCaptureFile("dcdcusb.txt"); err != nil {
+//			PS.log.Warn("Can't Open DCDCUSB Capture File for Simulation")
+//		}
+		PS.PowerSupply.Init(PS.log, true)
+	} else {
+		PS.PowerSupply.Init(PS.log, false);
+	}
 	ok, err := PS.PowerSupply.Scan()
 	if err != nil {
-		PS.log.Warn("Power Supply Scan Failed: %s", err)
+		PS.log.Error(err, "Power Supply Scan Failed")
 		return
 	}
 	if !ok {
-		PS.log.Warn("Power Supply Scan Returned False")
+		PS.log.Error(nil, "Power Supply Scan Returned False")
 	}
 	PS.ok = true
 	ctx := context.Background()
@@ -54,12 +61,12 @@ func (PS *PowerSupplyS) Start(log logadapter.Logger) {
 	PS.PowerSupply.GetAllParam(ctx)
 	fixedTimer1second, err := taskmanager.NewFixed(viper.GetDuration("powersupply.poll") * time.Second)
 	if err != nil {
-		PS.log.Panic("invalid interval: %s", err.Error())
+		PS.log.Error(err, "invalid interval")
 	}
 
 	err = tm.GetScheduler().Add(ctx, "PowerSupply", fixedTimer1second, PS.Poll)
 	if err != nil {
-		PS.log.Panic("Can't Initilize Scheduler for PowerSupply: %s", err)
+		PS.log.Error(err, "Can't Initilize Scheduler for PowerSupply")
 	}
 	PS.log.Info("Added PowerSupply Polling Schedule")
 	web.Web.GetEchoServer().GET("/power", PS.Publish)
@@ -79,12 +86,15 @@ func (PS *PowerSupplyS) Poll(ctx context.Context) {
 	PS.mx.Lock()
 	defer PS.mx.Unlock()
 	if !PS.ok {
-		PS.log.Warn("Polling for PowerSupply - Not Ready")
+		PS.log.Error(nil, "Polling for PowerSupply - Not Ready")
 		return
 	}
 	ctxnew, _ := context.WithTimeout(ctx, 1*time.Second)
-	PS.Params = PS.PowerSupply.GetAllParam(ctxnew)
-	natsconnection.Nats.SendStats("Power", PS.Params)
+	var err error
+	if PS.Params, err = PS.PowerSupply.GetAllParam(ctxnew); err != nil {
+		PS.log.Error(err, "GetAllParams Failed")
+	}
+	internal.ProcessUpdate("Power", PS.Params)
 }
 
 func (PS *PowerSupplyS) Publish(c echo.Context) error {
@@ -92,3 +102,7 @@ func (PS *PowerSupplyS) Publish(c echo.Context) error {
 	defer PS.mx.Unlock()
 	return c.JSON(http.StatusOK, PS.Params)
 }
+
+func (PS *PowerSupplyS) Process(string, interface{}) error {
+	return nil;
+}
\ No newline at end of file
diff --git a/internal/taskmanager/taskmanager.go b/internal/taskmanager/taskmanager.go
index 787ad2e..6a7debc 100644
--- a/internal/taskmanager/taskmanager.go
+++ b/internal/taskmanager/taskmanager.go
@@ -1,21 +1,20 @@
 package taskmanager
 
 import (
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/Fishwaldo/go-taskmanager"
+
 	//"github.com/Fishwaldo/go-taskmanager/job"
 	//executionmiddleware "github.com/Fishwaldo/go-taskmanager/middleware/executation"
 	//retrymiddleware "github.com/Fishwaldo/go-taskmanager/middleware/retry"
-	logruslog "github.com/Fishwaldo/go-taskmanager/loggers/logrus"
 )
 
 //var logger logadapter.Logger
 var scheduler *taskmanager.Scheduler
 
-func InitScheduler(log logadapter.Logger) {
-	logger :=  logruslog.LogrusDefaultLogger();
+func InitScheduler(log logr.Logger) {
 	scheduler = taskmanager.NewScheduler(
-		taskmanager.WithLogger(logger),
+		taskmanager.WithLogger(log),
 	)
 }
 
diff --git a/internal/web/web.go b/internal/web/web.go
index f55ebea..892cfbb 100644
--- a/internal/web/web.go
+++ b/internal/web/web.go
@@ -3,10 +3,12 @@ package web
 import (
 	"net/http"
 	"fmt"
+	"sync"
 
-	"github.com/Fishwaldo/go-logadapter"
+	"github.com/go-logr/logr"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
+	"golang.org/x/net/websocket"
 	"github.com/spf13/viper"
 )
 
@@ -16,13 +18,19 @@ func init() {
 
 type WebServer struct {
 	Echo *echo.Echo
-	log  logadapter.Logger
+	log  logr.Logger
 }
 var (
 	Web WebServer
+	connectionPool = struct {
+		sync.RWMutex
+		connections map[*websocket.Conn]struct{}
+	}{
+		connections: make(map[*websocket.Conn]struct{}),
+	}
 )
 
-func (web *WebServer) Start(log logadapter.Logger) {
+func (web *WebServer) Start(log logr.Logger) {
 	web.log = log
 	web.Echo = echo.New()
 	// Middleware
@@ -30,13 +38,17 @@ func (web *WebServer) Start(log logadapter.Logger) {
 	web.Echo.Use(middleware.Recover())
 
 	// Routes
-	web.Echo.GET("/", homePage)
+	web.Echo.GET("/", web.homePage)
+	web.Echo.GET("/ws", web.WebSocket)
 
 	// Start server
 	go func() {
 		port := viper.GetInt("web.port")
 		bind := fmt.Sprintf(":%d", port)
-		web.log.Fatal("%s", web.Echo.Start(bind))
+		err := web.Echo.Start(bind)
+		if err != nil {
+			log.Error(err, "Web Server Error")
+		}
 	}()
 }
 
@@ -44,6 +56,46 @@ func (web *WebServer) GetEchoServer() (*echo.Echo) {
 	return Web.Echo
 }
 
-func homePage(c echo.Context) error {
+func  (web *WebServer) homePage(c echo.Context) error {
 	return c.String(http.StatusOK, "Hello, World!")
 }
+
+func (web *WebServer) WebSocket(c echo.Context) error {
+	websocket.Handler(func(ws *websocket.Conn) {
+		web.log.Info("Opened WebSocket")
+        connectionPool.Lock()
+        connectionPool.connections[ws] = struct{}{}
+
+        defer func(connection *websocket.Conn){
+            connectionPool.Lock()
+            delete(connectionPool.connections, connection)
+            connectionPool.Unlock()
+        }(ws)
+
+        connectionPool.Unlock()
+		defer ws.Close()
+		for {
+			// Read
+			msg := ""
+			err := websocket.Message.Receive(ws, &msg)
+			if err != nil {
+				c.Logger().Error(err)
+				break;
+			}
+			web.log.Info("%s\n", msg)
+		}
+		web.log.Info("Closed WebSocket")
+	}).ServeHTTP(c.Response(), c.Request())
+	return nil	
+}
+
+func (web *WebServer) Broadcast(message string) {
+	connectionPool.RLock()
+	for connection := range connectionPool.connections {
+		err := websocket.Message.Send(connection, message)
+		if err != nil {
+			web.log.Error(err, "Broadcast Failure")
+		}
+	}
+	connectionPool.RUnlock()
+}
\ No newline at end of file
diff --git a/main.go b/main.go
index 249a67a..3fa43bd 100644
--- a/main.go
+++ b/main.go
@@ -12,7 +12,7 @@ import (
 	"github.com/Fishwaldo/CarTracker/internal"
 	_ "github.com/Fishwaldo/CarTracker/internal/config"
 
-	//"github.com/Fishwaldo/CarTracker/internal/dbus"
+	"github.com/Fishwaldo/CarTracker/internal/dbus"
 	_ "github.com/Fishwaldo/CarTracker/internal/gps"
 	"github.com/Fishwaldo/CarTracker/internal/natsconnection"
 	_ "github.com/Fishwaldo/CarTracker/internal/perf"
@@ -20,8 +20,9 @@ import (
 	"github.com/Fishwaldo/CarTracker/internal/taskmanager"
 	"github.com/Fishwaldo/CarTracker/internal/update"
 	"github.com/Fishwaldo/CarTracker/internal/web"
-	"github.com/Fishwaldo/go-logadapter/loggers/logrus"
 	"github.com/blang/semver/v4"
+	"github.com/bombsimon/logrusr/v2"
+	"github.com/sirupsen/logrus"
 )
 
 var (
@@ -34,7 +35,8 @@ func init() {
 }
 
 func main() {
-	logger := logrus.LogrusDefaultLogger()
+	logsink := logrus.New()
+	logger := logrusr.New(logsink)
 
 	//logger.SetLevel(logadapter.LOG_TRACE)
 
@@ -52,21 +54,23 @@ func main() {
 		}
 	}
 	
-	logger.Info("Starting CarTracker Version %s\n", versionstring)
+	logger.Info("Starting CarTracker", "version", versionstring)
 	if latest, err := update.GitHubLatestRelease(context.Background(), "Fishwaldo", "CarTracker"); err != nil {
-		logger.Warn("Cant Find Latest Release Info From Github: %s", err)
+		logger.Error(err, "Cant Find Latest Release Info From Github")
 	} else {
-		logger.Info("Latest Release is %s", latest.String());
+		logger.Info("Latest Release", "version", latest.String());
 	}
 
-	//dbus.DBUS.Start(logger)
+	dbus.DBUS.Start(logger)
 
-	natsconnection.Nats.Start(logger.New("NATS"))
-	web.Web.Start(logger.New("WEB"))
-	taskmanager.InitScheduler(logger.New("TaskManager"))
+	natsconnection.Nats.Start(logger.WithName("NATS"))
+	web.Web.Start(logger.WithName("WEB"))
+	taskmanager.InitScheduler(logger.WithName("TaskManager"))
 
 	internal.StartPlugins(logger)
 
+	internal.InitStatusUpdate()
+
 	taskmanager.StartScheduler()
 
 	logger.Info("Server Started")
@@ -75,7 +79,7 @@ func main() {
 	signal.Notify(signalChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT)
 
 	s := <-signalChan
-	logger.Info("Got Shutdown Signal %s", s)
+	logger.Info("Got Shutdown Signal", "signal", s)
 
 	internal.StopPlugins()