diff --git a/main.cpp b/main.cpp
index 55a6d2e..73e43c8 100644
--- a/main.cpp
+++ b/main.cpp
@@ -81,7 +81,7 @@
 void restartControlLoops()
 {
     static SensorManager mgmr;
-    static std::unordered_map<int64_t, std::unique_ptr<DbusPidZone>> zones;
+    static std::unordered_map<int64_t, std::unique_ptr<ZoneInterface>> zones;
     static std::list<boost::asio::steady_timer> timers;
 
     timers.clear();
diff --git a/pid/builder.cpp b/pid/builder.cpp
index a5f0ef1..c6b8eaf 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -21,6 +21,8 @@
 #include "pid/fancontroller.hpp"
 #include "pid/stepwisecontroller.hpp"
 #include "pid/thermalcontroller.hpp"
+#include "pid/zone.hpp"
+#include "pid/zone_interface.hpp"
 
 #include <sdbusplus/bus.hpp>
 
@@ -39,12 +41,12 @@
     return std::string(objectPath) + std::to_string(zone);
 }
 
-std::unordered_map<int64_t, std::unique_ptr<DbusPidZone>>
+std::unordered_map<int64_t, std::unique_ptr<ZoneInterface>>
     buildZones(const std::map<int64_t, conf::PIDConf>& zonePids,
                std::map<int64_t, struct conf::ZoneConfig>& zoneConfigs,
                SensorManager& mgr, sdbusplus::bus::bus& modeControlBus)
 {
-    std::unordered_map<int64_t, std::unique_ptr<DbusPidZone>> zones;
+    std::unordered_map<int64_t, std::unique_ptr<ZoneInterface>> zones;
 
     for (const auto& zi : zonePids)
     {
diff --git a/pid/builder.hpp b/pid/builder.hpp
index 4db7447..ff2f682 100644
--- a/pid/builder.hpp
+++ b/pid/builder.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
-#include "pid/zone.hpp"
+#include "conf.hpp"
+#include "pid/zone_interface.hpp"
 #include "sensors/manager.hpp"
 
 #include <sdbusplus/bus.hpp>
@@ -11,7 +12,7 @@
 namespace pid_control
 {
 
-std::unordered_map<int64_t, std::unique_ptr<DbusPidZone>>
+std::unordered_map<int64_t, std::unique_ptr<ZoneInterface>>
     buildZones(const std::map<int64_t, conf::PIDConf>& zonePids,
                std::map<int64_t, struct conf::ZoneConfig>& zoneConfigs,
                SensorManager& mgr, sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/pidloop.cpp b/pid/pidloop.cpp
index fe6c9b7..1cdf019 100644
--- a/pid/pidloop.cpp
+++ b/pid/pidloop.cpp
@@ -18,6 +18,7 @@
 
 #include "pid/pidcontroller.hpp"
 #include "pid/tuning.hpp"
+#include "pid/zone_interface.hpp"
 #include "sensors/sensor.hpp"
 
 #include <boost/asio/steady_timer.hpp>
@@ -25,13 +26,14 @@
 #include <chrono>
 #include <map>
 #include <memory>
+#include <sstream>
 #include <thread>
 #include <vector>
 
 namespace pid_control
 {
 
-static void processThermals(DbusPidZone* zone)
+static void processThermals(ZoneInterface* zone)
 {
     // Get the latest margins.
     zone->updateSensors();
@@ -44,7 +46,7 @@
     zone->determineMaxSetPointRequest();
 }
 
-void pidControlLoop(DbusPidZone* zone, boost::asio::steady_timer& timer,
+void pidControlLoop(ZoneInterface* zone, boost::asio::steady_timer& timer,
                     bool first, int ms100cnt)
 {
     if (first)
@@ -115,8 +117,9 @@
 
             if (loggingEnabled)
             {
-                zone->getLogHandle() << "," << zone->getFailSafeMode();
-                zone->getLogHandle() << std::endl;
+                std::ostringstream out;
+                out << "," << zone->getFailSafeMode() << std::endl;
+                zone->writeLog(out.str());
             }
 
             ms100cnt += 1;
diff --git a/pid/pidloop.hpp b/pid/pidloop.hpp
index c8365e3..0b8690b 100644
--- a/pid/pidloop.hpp
+++ b/pid/pidloop.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "pid/zone.hpp"
+#include "pid/zone_interface.hpp"
 
 #include <boost/asio/steady_timer.hpp>
 
@@ -12,12 +12,12 @@
  * This function calls itself indefinitely in an async loop to calculate
  * fan outputs based on thermal inputs.
  *
- * @param[in] zone - ptr to the DbusPidZone for this loop.
+ * @param[in] zone - ptr to the ZoneInterface implementation for this loop.
  * @param[in] timer - boost timer used for async callback.
  * @param[in] first - boolean to denote if initialization needs to be run.
  * @param[in] ms100cnt - loop timer counter.
  */
-void pidControlLoop(DbusPidZone* zone, boost::asio::steady_timer& timer,
+void pidControlLoop(ZoneInterface* zone, boost::asio::steady_timer& timer,
                     bool first = true, int ms100cnt = 0);
 
 } // namespace pid_control
diff --git a/pid/zone.cpp b/pid/zone.cpp
index ca0f67f..9621993 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -31,6 +31,7 @@
 #include <fstream>
 #include <iostream>
 #include <memory>
+#include <string>
 
 namespace pid_control
 {
@@ -196,9 +197,10 @@
     return;
 }
 
-std::ofstream& DbusPidZone::getLogHandle(void)
+void DbusPidZone::writeLog(const std::string& value)
 {
-    return _log;
+    _log << value;
+    return;
 }
 
 /*
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 254ea42..3bea9c2 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -49,30 +49,30 @@
         }
     }
 
-    double getMaxSetPointRequest(void) const override;
-    bool getManualMode(void) const;
-
+    bool getManualMode(void) const override;
     /* Could put lock around this since it's accessed from two threads, but
      * only one reader/one writer.
      */
     void setManualMode(bool mode);
     bool getFailSafeMode(void) const override;
+
     int64_t getZoneID(void) const;
     void addSetPoint(double setpoint) override;
+    double getMaxSetPointRequest(void) const override;
     void addRPMCeiling(double ceiling) override;
-    void clearSetPoints(void);
-    void clearRPMCeilings(void);
+    void clearSetPoints(void) override;
+    void clearRPMCeilings(void) override;
     double getFailSafePercent(void) const override;
     double getMinThermalSetpoint(void) const;
 
     Sensor* getSensor(const std::string& name) override;
-    void determineMaxSetPointRequest(void);
-    void updateFanTelemetry(void);
-    void updateSensors(void);
-    void initializeCache(void);
+    void determineMaxSetPointRequest(void) override;
+    void updateFanTelemetry(void) override;
+    void updateSensors(void) override;
+    void initializeCache(void) override;
     void dumpCache(void);
-    void processFans(void);
-    void processThermals(void);
+    void processFans(void) override;
+    void processThermals(void) override;
 
     void addFanPID(std::unique_ptr<Controller> pid);
     void addThermalPID(std::unique_ptr<Controller> pid);
@@ -80,8 +80,8 @@
     void addFanInput(const std::string& fan);
     void addThermalInput(const std::string& therm);
 
-    void initializeLog(void);
-    std::ofstream& getLogHandle(void);
+    void initializeLog(void) override;
+    void writeLog(const std::string& value) override;
 
     /* Method for setting the manual mode over dbus */
     bool manual(bool value) override;
diff --git a/pid/zone_interface.hpp b/pid/zone_interface.hpp
index f701064..a024c0e 100644
--- a/pid/zone_interface.hpp
+++ b/pid/zone_interface.hpp
@@ -7,18 +7,79 @@
 namespace pid_control
 {
 
+/**
+ * In a Zone you have a set of PIDs which feed each other.  Fan PIDs are fed set
+ * points from Thermal PIDs.
+ */
 class ZoneInterface
 {
   public:
     virtual ~ZoneInterface() = default;
 
-    virtual double getCachedValue(const std::string& name) = 0;
-    virtual void addSetPoint(double setpoint) = 0;
-    virtual void addRPMCeiling(double ceiling) = 0;
-    virtual double getMaxSetPointRequest() const = 0;
-    virtual bool getFailSafeMode() const = 0;
-    virtual double getFailSafePercent() const = 0;
+    /** If the zone implementation supports logging, initialize the log. */
+    virtual void initializeLog(void) = 0;
+    /** If the zone implementation supports logging, write string to log. */
+    virtual void writeLog(const std::string& value) = 0;
+
+    /** Return a pointer to the sensor specified by name. */
     virtual Sensor* getSensor(const std::string& name) = 0;
+
+    /* updateFanTelemetry() and updateSensors() both clear the failsafe state
+     * for a sensor if it's no longer in that state.
+     */
+    /** For each fan input in the zone, read each to update the cachedValue and
+     * check if the fan is beyond its timeout to trigger a failsafe condition.
+     */
+    virtual void updateFanTelemetry(void) = 0;
+    /** For each thermal input in the zone, read each to update the cachedValue
+     * and check if the sensor is beyond its timeout to trigger a failsafe
+     * condition.
+     */
+    virtual void updateSensors(void) = 0;
+    /** For each fan and thermal input in the zone, set the cachedValue to 0 and
+     * set the input as failsafe - to default the zone to failsafe before it
+     * starts processing values to control fans.
+     */
+    virtual void initializeCache(void) = 0;
+    /** Return cached value for sensor by name. */
+    virtual double getCachedValue(const std::string& name) = 0;
+
+    /** Add a set point value for the Max Set Point computation. */
+    virtual void addSetPoint(double setpoint) = 0;
+    /** Clear all set points specified via addSetPoint */
+    virtual void clearSetPoints(void) = 0;
+
+    /** Add maximum RPM value to drive fan pids. */
+    virtual void addRPMCeiling(double ceiling) = 0;
+    /** Clear any RPM value set with addRPMCeiling. */
+    virtual void clearRPMCeilings(void) = 0;
+
+    /** Compute the value returned by getMaxSetPointRequest - called from the
+     * looping mechanism before triggering any Fan PIDs. The value computed is
+     * used by each fan PID.
+     */
+    virtual void determineMaxSetPointRequest(void) = 0;
+    /** Given the set points added via addSetPoint, return the maximum value -
+     * called from the PID loop that uses that value to drive the fans.
+     */
+    virtual double getMaxSetPointRequest() const = 0;
+
+    /** Return if the zone has any sensors in fail safe mode. */
+    virtual bool getFailSafeMode() const = 0;
+    /** Return the rpm or pwm percent value to drive fan pids when zone is in
+     * fail safe.
+     */
+    virtual double getFailSafePercent() const = 0;
+
+    /** Return if the zone is set to manual mode.  false equates to automatic
+     * mode (the default).
+     */
+    virtual bool getManualMode(void) const = 0;
+
+    /** For each fan pid, do processing. */
+    virtual void processFans(void) = 0;
+    /** For each thermal pid, do processing. */
+    virtual void processThermals(void) = 0;
 };
 
 } // namespace pid_control
diff --git a/test/controller_mock.hpp b/test/controller_mock.hpp
index 63353a1..d2375b1 100644
--- a/test/controller_mock.hpp
+++ b/test/controller_mock.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "pid/controller.hpp"
+#include "pid/zone_interface.hpp"
 
 #include <gmock/gmock.h>
 
@@ -12,7 +13,7 @@
   public:
     virtual ~ControllerMock() = default;
 
-    ControllerMock(const std::string& id, DbusPidZone* owner) :
+    ControllerMock(const std::string& id, ZoneInterface* owner) :
         PIDController(id, owner)
     {}
 
diff --git a/test/zone_mock.hpp b/test/zone_mock.hpp
index f5044f8..48b7e9a 100644
--- a/test/zone_mock.hpp
+++ b/test/zone_mock.hpp
@@ -14,13 +14,29 @@
   public:
     virtual ~ZoneMock() = default;
 
+    MOCK_METHOD0(updateFanTelemetry, void());
+    MOCK_METHOD0(updateSensors, void());
+    MOCK_METHOD0(initializeCache, void());
     MOCK_METHOD1(getCachedValue, double(const std::string&));
+
     MOCK_METHOD1(addSetPoint, void(double));
+    MOCK_METHOD0(clearSetPoints, void());
     MOCK_METHOD1(addRPMCeiling, void(double));
+    MOCK_METHOD0(clearRPMCeilings, void());
+    MOCK_METHOD0(determineMaxSetPointRequest, void());
     MOCK_CONST_METHOD0(getMaxSetPointRequest, double());
+
+    MOCK_METHOD0(processFans, void());
+    MOCK_METHOD0(processThermals, void());
+
+    MOCK_CONST_METHOD0(getManualMode, bool());
     MOCK_CONST_METHOD0(getFailSafeMode, bool());
     MOCK_CONST_METHOD0(getFailSafePercent, double());
+
     MOCK_METHOD1(getSensor, Sensor*(const std::string&));
+
+    MOCK_METHOD0(initializeLog, void());
+    MOCK_METHOD1(writeLog, void(const std::string&));
 };
 
 } // namespace pid_control