diff --git a/opm/parser/eclipse/Applications/opm-eclkwtest.cpp b/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
index 4836d4544..513a31dc5 100644
--- a/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
+++ b/opm/parser/eclipse/Applications/opm-eclkwtest.cpp
@@ -18,7 +18,7 @@
  */
 
 #include <iostream>
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 #include <opm/parser/eclipse/OpmLog/StreamLog.hpp>
 #include <opm/parser/eclipse/OpmLog/LogUtil.hpp>
 
@@ -27,7 +27,7 @@
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
 
 
-static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::MessageCounterConstPtr logger, bool printAllKeywords) {
+static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::CounterLogConstPtr logger, bool printAllKeywords) {
     int recognizedKeywords = 0;
     int unrecognizedKeywords = 0;
 
@@ -71,7 +71,7 @@ int main(int argc, char** argv) {
 
     Opm::ParserPtr parser(new Opm::Parser());
     std::string file = argv[1];
-    Opm::MessageCounterPtr logger(new Opm::MessageCounter);
+    Opm::CounterLogPtr logger(new Opm::CounterLog);
     Opm::DeckConstPtr deck = parser->parseFile(file, logger);
     Opm::EclipseState state(deck);
 
diff --git a/opm/parser/eclipse/CMakeLists.txt b/opm/parser/eclipse/CMakeLists.txt
index 5cf7a396f..7afb99cf9 100644
--- a/opm/parser/eclipse/CMakeLists.txt
+++ b/opm/parser/eclipse/CMakeLists.txt
@@ -15,7 +15,7 @@ endif()
 add_subdirectory( Applications )
 
 set( log_source
-OpmLog/MessageCounter.cpp 
+OpmLog/CounterLog.cpp 
 OpmLog/LogUtil.cpp
 OpmLog/Logger.cpp 
 OpmLog/LogBackend.cpp 
@@ -108,7 +108,7 @@ EclipseState/SimulationConfig/ThresholdPressure.cpp)
 
 set( HEADER_FILES
 OpmLog/LogBackend.hpp
-OpmLog/MessageCounter.hpp
+OpmLog/CounterLog.hpp
 OpmLog/Logger.hpp
 OpmLog/OpmLog.hpp
 OpmLog/LogUtil.hpp
diff --git a/opm/parser/eclipse/Deck/Section.cpp b/opm/parser/eclipse/Deck/Section.cpp
index c059e6a4f..d37686dba 100644
--- a/opm/parser/eclipse/Deck/Section.cpp
+++ b/opm/parser/eclipse/Deck/Section.cpp
@@ -24,7 +24,7 @@
 #include <set>
 #include <string>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/Deck/Section.hpp>
@@ -100,7 +100,7 @@ namespace Opm {
     }
 
     bool Section::checkSectionTopology(DeckConstPtr deck,
-                                       MessageCounterPtr logger,
+                                       CounterLogPtr logger,
                                        bool ensureKeywordSectionAffiliation)
     {
         if (deck->size() == 0) {
diff --git a/opm/parser/eclipse/Deck/Section.hpp b/opm/parser/eclipse/Deck/Section.hpp
index 0eddce861..865e8528f 100644
--- a/opm/parser/eclipse/Deck/Section.hpp
+++ b/opm/parser/eclipse/Deck/Section.hpp
@@ -20,7 +20,7 @@
 #ifndef SECTION_HPP
 #define SECTION_HPP
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
@@ -56,7 +56,7 @@ namespace Opm {
         // returns whether the deck has all mandatory sections and if all sections are in
         // the right order
         static bool checkSectionTopology(DeckConstPtr deck,
-                                         MessageCounterPtr logger,
+                                         CounterLogPtr logger,
                                          bool ensureKeywordSectionAffiliation = false);
 
     private:
diff --git a/opm/parser/eclipse/Deck/tests/DeckTests.cpp b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
index 891f998a0..5caf99386 100644
--- a/opm/parser/eclipse/Deck/tests/DeckTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
@@ -24,7 +24,7 @@
 
 #include <boost/test/unit_test.hpp>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 #include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
@@ -123,13 +123,13 @@ BOOST_AUTO_TEST_CASE(size_twokeyword_return2) {
 
 
 BOOST_AUTO_TEST_CASE(DECKWARNING_EMPTYOK) {
-    MessageCounter logger;
+    CounterLog logger;
     BOOST_CHECK_EQUAL(0U, logger.size());
 }
 
 
 BOOST_AUTO_TEST_CASE(DECKAddWarning) {
-    MessageCounter logger;
+    CounterLog logger;
     logger.addNote("FILE", 100U, "NOTE");
     BOOST_CHECK_EQUAL(1U, logger.size());
 
diff --git a/opm/parser/eclipse/Deck/tests/SectionTests.cpp b/opm/parser/eclipse/Deck/tests/SectionTests.cpp
index 8d8ebf77c..40046e157 100644
--- a/opm/parser/eclipse/Deck/tests/SectionTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/SectionTests.cpp
@@ -243,7 +243,7 @@ BOOST_AUTO_TEST_CASE(Section_ValidDecks) {
     deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
     deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
 
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     BOOST_CHECK(Opm::Section::checkSectionTopology(deck, logger));
 
     // deck with all optional sections
@@ -295,7 +295,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
     deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
     deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
 
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
 
     // wrong section order
diff --git a/opm/parser/eclipse/EclipseState/EclipseState.cpp b/opm/parser/eclipse/EclipseState/EclipseState.cpp
index efcdc7b19..03be5482c 100644
--- a/opm/parser/eclipse/EclipseState/EclipseState.cpp
+++ b/opm/parser/eclipse/EclipseState/EclipseState.cpp
@@ -22,7 +22,7 @@
 #include <math.h>
 #include <boost/algorithm/string/join.hpp>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 #include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
@@ -121,7 +121,7 @@ namespace Opm {
     }
 
 
-    EclipseState::EclipseState(DeckConstPtr deck, MessageCounterPtr logger)
+    EclipseState::EclipseState(DeckConstPtr deck, CounterLogPtr logger)
         : m_defaultRegion("FLUXNUM")
     {
         m_deckUnitSystem = deck->getActiveUnitSystem();
@@ -264,7 +264,7 @@ namespace Opm {
         return m_title;
     }
 
-    void EclipseState::initTables(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initTables(DeckConstPtr deck, CounterLogPtr logger) {
         initSimpleTables(deck, logger, "ENKRVD", m_enkrvdTables);
         initSimpleTables(deck, logger, "ENPTVD", m_enptvdTables);
         initSimpleTables(deck, logger, "IMKRVD", m_imkrvdTables);
@@ -315,7 +315,7 @@ namespace Opm {
         m_simulationConfig = std::make_shared<const SimulationConfig>(deck , m_intGridProperties);
     }
 
-    void EclipseState::initTransMult(MessageCounterPtr /*logger*/) {
+    void EclipseState::initTransMult(CounterLogPtr /*logger*/) {
         EclipseGridConstPtr grid = getEclipseGrid();
         m_transMult = std::make_shared<TransMult>( grid->getNX() , grid->getNY() , grid->getNZ());
 
@@ -335,7 +335,7 @@ namespace Opm {
             m_transMult->applyMULT(m_doubleGridProperties->getKeyword("MULTZ-"), FaceDir::ZMinus);
     }
 
-    void EclipseState::initFaults(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initFaults(DeckConstPtr deck, CounterLogPtr logger) {
         EclipseGridConstPtr grid = getEclipseGrid();
         m_faults = std::make_shared<FaultCollection>();
         std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
@@ -381,7 +381,7 @@ namespace Opm {
 
 
 
-    void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, MessageCounterPtr /*logger*/) const {
+    void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, CounterLogPtr /*logger*/) const {
         for (size_t index=0; index < section->count("MULTFLT"); index++) {
             DeckKeywordConstPtr faultsKeyword = section->getKeyword("MULTFLT" , index);
             for (auto iter = faultsKeyword->begin(); iter != faultsKeyword->end(); ++iter) {
@@ -396,7 +396,7 @@ namespace Opm {
 
 
 
-    void EclipseState::initMULTREGT(DeckConstPtr deck, MessageCounterPtr /*logger*/) {
+    void EclipseState::initMULTREGT(DeckConstPtr deck, CounterLogPtr /*logger*/) {
         EclipseGridConstPtr grid = getEclipseGrid();
 
         std::vector<Opm::DeckKeywordConstPtr> multregtKeywords;
@@ -409,11 +409,12 @@ namespace Opm {
 
 
 
-    void EclipseState::initEclipseGrid(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initEclipseGrid(DeckConstPtr deck, CounterLogPtr logger) {
         m_eclipseGrid = EclipseGridConstPtr( new EclipseGrid(deck, logger));
     }
 
 
+<<<<<<< HEAD
     void EclipseState::initGridopts(DeckConstPtr deck) {
         if (deck->hasKeyword("GRIDOPTS")) {
             /*
@@ -461,7 +462,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::initPhases(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initPhases(DeckConstPtr deck, CounterLogPtr logger) {
         if (deck->hasKeyword("OIL"))
             phases.insert(Phase::PhaseEnum::OIL);
 
@@ -480,7 +481,7 @@ namespace Opm {
          return (phases.count(phase) == 1);
     }
 
-    void EclipseState::initTitle(DeckConstPtr deck, MessageCounterPtr /*logger*/){
+    void EclipseState::initTitle(DeckConstPtr deck, CounterLogPtr /*logger*/){
         if (deck->hasKeyword("TITLE")) {
             DeckKeywordConstPtr titleKeyword = deck->getKeyword("TITLE");
             DeckRecordConstPtr record = titleKeyword->getRecord(0);
@@ -490,7 +491,7 @@ namespace Opm {
         }
     }
 
-    void EclipseState::initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initRocktabTables(DeckConstPtr deck, CounterLogPtr logger) {
         if (!deck->hasKeyword("ROCKTAB"))
             return; // ROCKTAB is not featured by the deck...
 
@@ -630,7 +631,7 @@ namespace Opm {
 
     void EclipseState::loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
                                                        DeckKeywordConstPtr deckKeyword,
-                                                       MessageCounterPtr logger,
+                                                       CounterLogPtr logger,
                                                        int enabledTypes) {
         const std::string& keyword = deckKeyword->name();
         if (m_intGridProperties->supportsKeyword( keyword )) {
@@ -651,7 +652,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::initProperties(DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseState::initProperties(DeckConstPtr deck, CounterLogPtr logger) {
         typedef GridProperties<int>::SupportedKeywordInfo SupportedIntKeywordInfo;
         std::shared_ptr<std::vector<SupportedIntKeywordInfo> > supportedIntKeywords(new std::vector<SupportedIntKeywordInfo>{
             SupportedIntKeywordInfo( "SATNUM" , 1, "1" ),
@@ -869,7 +870,7 @@ namespace Opm {
         return m_deckUnitSystem->getDimension(dimensionString)->getSIScaling();
     }
 
-    void EclipseState::processGridProperties(Opm::DeckConstPtr deck, MessageCounterPtr logger, int enabledTypes) {
+    void EclipseState::processGridProperties(Opm::DeckConstPtr deck, CounterLogPtr logger, int enabledTypes) {
 
         if (Section::hasGRID(deck)) {
             std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
@@ -899,7 +900,7 @@ namespace Opm {
     }
 
     void EclipseState::scanSection(std::shared_ptr<Opm::Section> section,
-                                   MessageCounterPtr logger,
+                                   CounterLogPtr logger,
                                    int enabledTypes) {
         BoxManager boxManager(m_eclipseGrid->getNX( ) , m_eclipseGrid->getNY() , m_eclipseGrid->getNZ());
         for (auto iter = section->begin(); iter != section->end(); ++iter) {
@@ -947,7 +948,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr /*logger*/, BoxManager& boxManager) {
+    void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr /*logger*/, BoxManager& boxManager) {
         DeckRecordConstPtr record = deckKeyword->getRecord(0);
         int I1 = record->getItem("I1")->getInt(0) - 1;
         int I2 = record->getItem("I2")->getInt(0) - 1;
@@ -965,7 +966,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
+    void EclipseState::handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1008,7 +1009,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
+    void EclipseState::handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1053,7 +1054,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
+    void EclipseState::handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1094,7 +1095,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr , int enabledTypes) {
+    void EclipseState::handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr , int enabledTypes) {
         EclipseGridConstPtr grid = getEclipseGrid();
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
@@ -1138,7 +1139,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1170,7 +1171,7 @@ namespace Opm {
       some state dependent semantics regarding endpoint scaling arrays
       in the PROPS section. That is not supported.
     */
-    void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1200,7 +1201,7 @@ namespace Opm {
     }
 
 
-    void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& field = record->getItem("field")->getString(0);
@@ -1231,7 +1232,7 @@ namespace Opm {
 
 
 
-    void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes) {
+    void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, BoxManager& boxManager, int enabledTypes) {
         for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
             DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
             const std::string& srcField = record->getItem("src")->getString(0);
@@ -1271,7 +1272,7 @@ namespace Opm {
 
 
 
-    void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, MessageCounterPtr logger, BoxManager& boxManager) {
+    void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, CounterLogPtr logger, BoxManager& boxManager) {
         auto deckRecord = deckKeyword->getRecord(recordIdx);
 
         DeckItemConstPtr I1Item = deckRecord->getItem("I1");
@@ -1314,7 +1315,7 @@ namespace Opm {
                                 "BOX modifiers on keywords must be either specified completely or not at all. Ignoring.");
     }
 
-    void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, MessageCounterPtr logger, const std::string& keywordName) const {
+    void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, CounterLogPtr logger, const std::string& keywordName) const {
         logger->addError("", -1,
                             "The "+keywordName+" keyword must be unique in the deck. Ignoring all!");
         auto keywords = deck->getKeywordList(keywordName);
diff --git a/opm/parser/eclipse/EclipseState/EclipseState.hpp b/opm/parser/eclipse/EclipseState/EclipseState.hpp
index 3620d3c70..bc72f131b 100644
--- a/opm/parser/eclipse/EclipseState/EclipseState.hpp
+++ b/opm/parser/eclipse/EclipseState/EclipseState.hpp
@@ -21,7 +21,7 @@
 #define OPM_ECLIPSE_STATE_HPP
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
 #include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
@@ -72,7 +72,7 @@ namespace Opm {
             AllProperties = IntProperties | DoubleProperties
         };
 
-        EclipseState(DeckConstPtr deck, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout));
+        EclipseState(DeckConstPtr deck, CounterLogPtr logger = std::make_shared<CounterLog>(&std::cout));
 
         ScheduleConstPtr getSchedule() const;
         SimulationConfigConstPtr getSimulationConfig() const;
@@ -91,7 +91,7 @@ namespace Opm {
 
         void loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
                                              DeckKeywordConstPtr deckKeyword,
-                                             MessageCounterPtr logger,
+                                             CounterLogPtr logger,
                                              int enabledTypes = AllProperties);
 
         std::shared_ptr<const FaultCollection> getFaults() const;
@@ -130,20 +130,20 @@ namespace Opm {
         std::shared_ptr<const UnitSystem> getDeckUnitSystem()  const;
 
     private:
-        void initTables(DeckConstPtr deck, MessageCounterPtr logger);
-        void initSchedule(DeckConstPtr deck, MessageCounterPtr logger);
+        void initTables(DeckConstPtr deck, CounterLogPtr logger);
+        void initSchedule(DeckConstPtr deck, CounterLogPtr logger);
         void initSimulationConfig(DeckConstPtr deck);
-        void initEclipseGrid(DeckConstPtr deck, MessageCounterPtr logger);
+        void initEclipseGrid(DeckConstPtr deck, CounterLogPtr logger);
         void initGridopts(DeckConstPtr deck);
-        void initPhases(DeckConstPtr deck, MessageCounterPtr logger);
-        void initTitle(DeckConstPtr deck, MessageCounterPtr logger);
-        void initProperties(DeckConstPtr deck, MessageCounterPtr logger);
-        void initTransMult(MessageCounterPtr logger);
-        void initFaults(DeckConstPtr deck, MessageCounterPtr logger);
+        void initPhases(DeckConstPtr deck, CounterLogPtr logger);
+        void initTitle(DeckConstPtr deck, CounterLogPtr logger);
+        void initProperties(DeckConstPtr deck, CounterLogPtr logger);
+        void initTransMult(CounterLogPtr logger);
+        void initFaults(DeckConstPtr deck, CounterLogPtr logger);
 
         template <class TableType>
         void initSimpleTables(DeckConstPtr deck,
-                              MessageCounterPtr logger,
+                              CounterLogPtr logger,
                               const std::string& keywordName,
                               std::vector<TableType>& tableVector) {
             if (!deck->hasKeyword(keywordName))
@@ -177,7 +177,7 @@ namespace Opm {
 
         template <class TableType>
         void initFullTables(DeckConstPtr deck,
-                            MessageCounterPtr logger,
+                            CounterLogPtr logger,
                             const std::string& keywordName,
                             std::vector<TableType>& tableVector) {
             if (!deck->hasKeyword(keywordName))
@@ -197,38 +197,37 @@ namespace Opm {
             }
         }
 
-        void initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger);
+        void initRocktabTables(DeckConstPtr deck, CounterLogPtr logger);
         void initGasvisctTables(DeckConstPtr deck,
-                                LoggerPtr logger,
+                                CounterLogPtr logger,
                                 const std::string& keywordName,
                                 std::vector<GasvisctTable>& tableVector);
-        void initRocktabTables(DeckConstPtr deck, MessageCounterPtr logger);
 
-        void setMULTFLT(std::shared_ptr<const Section> section, MessageCounterPtr logger) const;
-        void initMULTREGT(DeckConstPtr deck, MessageCounterPtr logger);
+        void setMULTFLT(std::shared_ptr<const Section> section, CounterLogPtr logger) const;
+        void initMULTREGT(DeckConstPtr deck, CounterLogPtr logger);
 
         double getSIScaling(const std::string &dimensionString) const;
 
-        void processGridProperties(Opm::DeckConstPtr deck, MessageCounterPtr logger, int enabledTypes);
-        void scanSection(std::shared_ptr<Opm::Section> section, MessageCounterPtr logger, int enabledTypes);
-        void handleADDKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
-        void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager);
-        void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
+        void processGridProperties(Opm::DeckConstPtr deck, CounterLogPtr logger, int enabledTypes);
+        void scanSection(std::shared_ptr<Opm::Section> section, CounterLogPtr logger, int enabledTypes);
+        void handleADDKeyword(DeckKeywordConstPtr deckKeyword , CounterLogPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , CounterLogPtr logger, BoxManager& boxManager);
+        void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , CounterLogPtr logger, BoxManager& boxManager, int enabledTypes);
         void handleENDBOXKeyword(BoxManager& boxManager);
-        void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
-        void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , MessageCounterPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , CounterLogPtr logger, BoxManager& boxManager, int enabledTypes);
+        void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , CounterLogPtr logger, BoxManager& boxManager, int enabledTypes);
 
-        void handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
-        void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
-        void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
-        void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, MessageCounterPtr logger, int enabledTypes);
+        void handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, int enabledTypes);
+        void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, int enabledTypes);
+        void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, int enabledTypes);
+        void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, CounterLogPtr logger, int enabledTypes);
 
-        void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, MessageCounterPtr logger, BoxManager& boxManager);
+        void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, CounterLogPtr logger, BoxManager& boxManager);
 
         void copyIntKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
         void copyDoubleKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
 
-        void complainAboutAmbiguousKeyword(DeckConstPtr deck, MessageCounterPtr logger, const std::string& keywordName) const;
+        void complainAboutAmbiguousKeyword(DeckConstPtr deck, CounterLogPtr logger, const std::string& keywordName) const;
 
         EclipseGridConstPtr m_eclipseGrid;
         ScheduleConstPtr schedule;
diff --git a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
index 7228e8115..8ad4381d9 100644
--- a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
+++ b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
@@ -96,7 +96,7 @@ namespace Opm {
         }
     } // anonymous namespace
 
-    EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, MessageCounterPtr logger)
+    EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, CounterLogPtr logger)
         : m_minpvValue(0),
           m_minpvMode(MinpvMode::ModeEnum::Inactive),
           m_pinch("PINCH")
@@ -146,7 +146,7 @@ namespace Opm {
     }
 
 
-    void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, CounterLogPtr logger) {
         m_nx = static_cast<size_t>(dims[0]);
         m_ny = static_cast<size_t>(dims[1]);
         m_nz = static_cast<size_t>(dims[2]);
@@ -259,7 +259,7 @@ namespace Opm {
 
 
 
-    void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger) {
+    void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, CounterLogPtr logger) {
         assertCornerPointKeywords( dims , deck, logger);
         {
             DeckKeywordConstPtr ZCORNKeyWord = deck->getKeyword("ZCORN");
@@ -318,7 +318,7 @@ namespace Opm {
     }
 
 
-    void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger)
+    void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, CounterLogPtr logger)
     {
         const int nx = dims[0];
         const int ny = dims[1];
diff --git a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
index 9c8de02f1..1cd40da44 100644
--- a/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
+++ b/opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
@@ -21,7 +21,7 @@
 #ifndef ECLIPSE_GRID_HPP_
 #define ECLIPSE_GRID_HPP_
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 #include <opm/parser/eclipse/Deck/Section.hpp>
@@ -70,7 +70,7 @@ namespace Opm {
         explicit EclipseGrid(const ecl_grid_type * src_ptr);
         explicit EclipseGrid(size_t nx, size_t ny, size_t nz,
                              double dx = 1.0, double dy = 1.0, double dz = 1.0);
-        explicit EclipseGrid(std::shared_ptr<const Deck> deck, MessageCounterPtr logger = std::make_shared<MessageCounter>());
+        explicit EclipseGrid(std::shared_ptr<const Deck> deck, CounterCounterPtr logger = std::make_shared<CounterCounter>());
         static bool hasCornerPointKeywords(std::shared_ptr<const Deck> deck);
         static bool hasCartesianKeywords(std::shared_ptr<const Deck> deck);
         size_t  getNumActive( ) const;
@@ -118,12 +118,12 @@ namespace Opm {
         void assertCellInfo() const;
 
         void initCartesianGrid(const std::vector<int>& dims , DeckConstPtr deck);
-        void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, MessageCounterPtr logger);
+        void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, CounterLogPtr logger);
         void initDTOPSGrid(const std::vector<int>& dims , DeckConstPtr deck);
         void initDVDEPTHZGrid(const std::vector<int>& dims , DeckConstPtr deck);
-        void initGrid(const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger);
+        void initGrid(const std::vector<int>& dims, DeckConstPtr deck, CounterLogPtr logger);
 
-        static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, MessageCounterPtr logger) ;
+        static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, CounterLogPtr logger) ;
         static bool hasDVDEPTHZKeywords(DeckConstPtr deck);
         static bool hasDTOPSKeywords(DeckConstPtr deck);
         static void assertVectorSize(const std::vector<double>& vector , size_t expectedSize , const std::string& msg);
diff --git a/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp b/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
index 97f084ea9..63d704aea 100644
--- a/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
+++ b/opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
@@ -25,7 +25,7 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
 
@@ -235,6 +235,6 @@ static Opm::DeckPtr createCopyMULTNUMDeck() {
 
 BOOST_AUTO_TEST_CASE(MULTREGT_COPY_MULTNUM) {
     Opm::DeckPtr deck = createCopyMULTNUMDeck();
-    Opm::MessageCounterPtr logger(new Opm::MessageCounter());
+    Opm::CounterLogPtr logger(new Opm::CounterLog());
     BOOST_CHECK_NO_THROW( Opm::EclipseState( deck, logger ));
 }
diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
index 5ba451ce3..567a2c7ea 100644
--- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
@@ -35,13 +35,13 @@
 
 namespace Opm {
 
-    Schedule::Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, MessageCounterPtr logger)
+    Schedule::Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, CounterLogPtr logger)
         : m_grid(grid)
     {
         initFromDeck(deck, logger);
     }
 
-    void Schedule::initFromDeck(DeckConstPtr deck, MessageCounterPtr logger) {
+    void Schedule::initFromDeck(DeckConstPtr deck, CounterLogPtr logger) {
         createTimeMap(deck, logger);
         addGroup( "FIELD", 0 );
         initRootGroupTreeNode(getTimeMap());
@@ -52,7 +52,7 @@ namespace Opm {
         m_rootGroupTree.reset(new DynamicState<GroupTreePtr>(timeMap, GroupTreePtr(new GroupTree())));
     }
 
-    void Schedule::createTimeMap(DeckConstPtr deck, MessageCounterPtr /*logger*/) {
+    void Schedule::createTimeMap(DeckConstPtr deck, CounterLogPtr /*logger*/) {
         boost::posix_time::ptime startTime(defaultStartDate);
         if (deck->hasKeyword("START")) {
             DeckKeywordConstPtr startKeyword = deck->getKeyword("START");
@@ -62,7 +62,7 @@ namespace Opm {
         m_timeMap.reset(new TimeMap(startTime));
     }
 
-    void Schedule::iterateScheduleSection(DeckConstPtr deck, MessageCounterPtr logger) {
+    void Schedule::iterateScheduleSection(DeckConstPtr deck, CounterLogPtr logger) {
         size_t currentStep = 0;
 
         std::vector<std::pair<DeckKeywordConstPtr , size_t> > rftProperties;
@@ -140,11 +140,11 @@ namespace Opm {
         checkUnhandledKeywords(deck);
     }
 
-    void Schedule::handleDATES(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/) {
+    void Schedule::handleDATES(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/) {
         m_timeMap->addFromDATESKeyword(keyword);
     }
 
-    void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/) {
+    void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/) {
         m_timeMap->addFromTSTEPKeyword(keyword);
     }
 
@@ -157,7 +157,7 @@ namespace Opm {
         return treeUpdated;
     }
 
-    void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
+    void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep) {
         bool needNewTree = false;
         GroupTreePtr newTree = m_rootGroupTree->get(currentStep)->deepCopy();
 
@@ -186,7 +186,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, MessageCounterPtr logger) const {
+    void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, CounterLogPtr logger) const {
         DeckRecordConstPtr record = keyword->getRecord(recordIdx);
         if (well->getHeadI() != record->getItem("HEAD_I")->getInt(0) - 1) {
             std::string msg =
@@ -206,7 +206,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep, bool isPredictionMode) {
+    void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep, bool isPredictionMode) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
 
@@ -260,15 +260,15 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
+    void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep) {
         handleWCONProducer(keyword, logger, currentStep, false);
     }
 
-    void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep) {
+    void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep) {
         handleWCONProducer(keyword, logger, currentStep, true);
     }
 
-    void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@@ -337,7 +337,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@@ -366,7 +366,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@@ -408,7 +408,8 @@ namespace Opm {
         return data;
     }
 
-    void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep , bool hascomplump) {
+
+    void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep, bool hascomplump) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
 
@@ -503,7 +504,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@@ -535,7 +536,7 @@ namespace Opm {
     }
 
 
-    void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@@ -557,7 +558,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         std::map<std::string , std::vector< CompletionPtr> > completionMapList = Completion::completionsFromCOMPDATKeyword( keyword );
         std::map<std::string , std::vector< CompletionPtr> >::iterator iter;
 
@@ -568,7 +569,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
             DeckRecordConstPtr record = keyword->getRecord(recordNr);
             const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@@ -589,7 +590,7 @@ namespace Opm {
         }
     }
 
-    void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, MessageCounterPtr /*logger*/, size_t currentStep) {
+    void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, CounterLogPtr /*logger*/, size_t currentStep) {
         GroupTreePtr currentTree = m_rootGroupTree->get(currentStep);
         GroupTreePtr newTree = currentTree->deepCopy();
         for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
diff --git a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
index 526b7567d..7021e4ed0 100644
--- a/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
+++ b/opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
@@ -19,7 +19,7 @@
 #ifndef SCHEDULE_HPP
 #define SCHEDULE_HPP
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
 #include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
@@ -42,7 +42,11 @@ namespace Opm
 
     class Schedule {
     public:
+<<<<<<< HEAD
         Schedule(std::shared_ptr<const EclipseGrid> grid , DeckConstPtr deck, MessageCounterPtr logger=std::make_shared<MessageCounter>());
+=======
+        Schedule(DeckConstPtr deck, CounterLogPtr logger=std::make_shared<CounterLog>());
+>>>>>>> Renamed MessageCounter -> CounterLog
         boost::posix_time::ptime getStartTime() const
         { return m_timeMap->getStartTime(/*timeStepIdx=*/0); }
         TimeMapConstPtr getTimeMap() const;
@@ -70,29 +74,29 @@ namespace Opm
         std::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
 
         void addWellToGroup( GroupPtr newGroup , WellPtr well , size_t timeStep);
-        void initFromDeck(DeckConstPtr deck, MessageCounterPtr logger);
-        void createTimeMap(DeckConstPtr deck, MessageCounterPtr logger);
+        void initFromDeck(DeckConstPtr deck, CounterLogPtr logger);
+        void createTimeMap(DeckConstPtr deck, CounterLogPtr logger);
         void initRootGroupTreeNode(TimeMapConstPtr timeMap);
-        void iterateScheduleSection(DeckConstPtr deck, MessageCounterPtr logger);
+        void iterateScheduleSection(DeckConstPtr deck, CounterLogPtr logger);
         bool handleGroupFromWELSPECS(const std::string& groupName, GroupTreePtr newTree) const;
         void addGroup(const std::string& groupName , size_t timeStep);
         void addWell(const std::string& wellName, DeckRecordConstPtr record, size_t timeStep);
-        void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, MessageCounterPtr logger) const;
-        void handleWELSPECS(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWCONProducer(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep, bool isPredictionMode);
-        void handleWCONHIST(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWGRUPCON(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleCOMPDAT(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWPOLYMER(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleWELOPEN(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleGCONPROD(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
-        void handleDATES(DeckKeywordConstPtr keyword, MessageCounterPtr logger);
-        void handleTSTEP(DeckKeywordConstPtr keyword, MessageCounterPtr logger);
-        void handleGRUPTREE(DeckKeywordConstPtr keyword, MessageCounterPtr logger, size_t currentStep);
+        void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, CounterLogPtr logger) const;
+        void handleWELSPECS(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWCONProducer(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep, bool isPredictionMode);
+        void handleWCONHIST(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWCONPROD(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWGRUPCON(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleCOMPDAT(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWPOLYMER(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleWELOPEN(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleGCONPROD(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
+        void handleDATES(DeckKeywordConstPtr keyword, CounterLogPtr logger);
+        void handleTSTEP(DeckKeywordConstPtr keyword, CounterLogPtr logger);
+        void handleGRUPTREE(DeckKeywordConstPtr keyword, CounterLogPtr logger, size_t currentStep);
         void handleWRFT(DeckKeywordConstPtr keyword, size_t currentStep);
         void handleWRFTPLT(DeckKeywordConstPtr keyword, size_t currentStep);
 
diff --git a/opm/parser/eclipse/EclipseState/checkDeck.cpp b/opm/parser/eclipse/EclipseState/checkDeck.cpp
index fd8d79a23..d00e6fc4f 100644
--- a/opm/parser/eclipse/EclipseState/checkDeck.cpp
+++ b/opm/parser/eclipse/EclipseState/checkDeck.cpp
@@ -21,7 +21,7 @@
 #include <opm/parser/eclipse/Deck/Section.hpp>
 
 namespace Opm {
-bool checkDeck(DeckConstPtr deck, MessageCounterPtr logger, size_t enabledChecks) {
+bool checkDeck(DeckConstPtr deck, CounterLogPtr logger, size_t enabledChecks) {
     bool deckValid = true;
 
     // make sure that the deck does not contain unknown keywords
diff --git a/opm/parser/eclipse/EclipseState/checkDeck.hpp b/opm/parser/eclipse/EclipseState/checkDeck.hpp
index 565c86dc5..e118302d6 100644
--- a/opm/parser/eclipse/EclipseState/checkDeck.hpp
+++ b/opm/parser/eclipse/EclipseState/checkDeck.hpp
@@ -20,7 +20,7 @@
 #ifndef OPM_CHECK_DECK_HPP
 #define OPM_CHECK_DECK_HPP
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
 
 namespace Opm {
@@ -37,7 +37,7 @@ enum DeckChecks {
 
 // some semantical correctness checks of the deck. this method adds a warning to
 // the deck object if any issue is found ...
-bool checkDeck(DeckConstPtr deck, MessageCounterPtr logger, size_t enabledChecks = AllChecks);
+bool checkDeck(DeckConstPtr deck, CounterLogPtr logger, size_t enabledChecks = AllChecks);
 }
 
 #endif
diff --git a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
index d76f10b58..64acbf35d 100644
--- a/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
+++ b/opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
@@ -86,7 +86,7 @@ static DeckPtr createDeckTOP() {
 
 BOOST_AUTO_TEST_CASE(GetPOROTOPBased) {
     DeckPtr deck = createDeckTOP();
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state(deck, logger);
 
     std::shared_ptr<GridProperty<double> > poro = state.getDoubleGridProperty( "PORO" );
@@ -252,7 +252,7 @@ BOOST_AUTO_TEST_CASE(IntProperties) {
 
 BOOST_AUTO_TEST_CASE(PropertiesNotSupportedThrows) {
     DeckPtr deck = createDeck();
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state(deck);
     DeckKeywordConstPtr swat = deck->getKeyword("SWAT");
     BOOST_CHECK_EQUAL( false , state.supportsGridProperty("SWAT"));
diff --git a/opm/parser/eclipse/IntegrationTests/BoxTest.cpp b/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
index 19f8e0f0d..2ce1fa632 100644
--- a/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
+++ b/opm/parser/eclipse/IntegrationTests/BoxTest.cpp
@@ -29,9 +29,9 @@
 using namespace Opm;
 
 // forward declaration to avoid a pedantic compiler warning
-EclipseState makeState(const std::string& fileName, MessageCounterPtr logger);
+EclipseState makeState(const std::string& fileName, CounterLogPtr logger);
 
-EclipseState makeState(const std::string& fileName, MessageCounterPtr logger) {
+EclipseState makeState(const std::string& fileName, CounterLogPtr logger) {
     ParserPtr parser(new Parser( ));
     boost::filesystem::path boxFile(fileName);
     DeckPtr deck =  parser->parseFile(boxFile.string());
@@ -42,7 +42,7 @@ EclipseState makeState(const std::string& fileName, MessageCounterPtr logger) {
 
 
 BOOST_AUTO_TEST_CASE( PERMX ) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1" , logger);
     std::shared_ptr<GridProperty<double> > permx = state.getDoubleGridProperty("PERMX");
     std::shared_ptr<GridProperty<double> > permy = state.getDoubleGridProperty("PERMY");
@@ -65,7 +65,7 @@ BOOST_AUTO_TEST_CASE( PERMX ) {
 
 
 BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
     {
@@ -90,7 +90,7 @@ BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
 
 
 BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
     std::shared_ptr<GridProperty<int> > fipnum = state.getIntGridProperty("FIPNUM");
@@ -114,21 +114,21 @@ BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
 
 
 BOOST_AUTO_TEST_CASE( INCOMPLETE_KEYWORD_BOX) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     makeState("testdata/integration_tests/BOX/BOXTEST2", logger);
     BOOST_CHECK(logger->numErrors() > 1);
 }
 
 
 BOOST_AUTO_TEST_CASE( KEYWORD_BOX_TOO_SMALL) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     BOOST_CHECK_THROW( makeState("testdata/integration_tests/BOX/BOXTEST3", logger) , std::invalid_argument);
 }
 
 
 
 BOOST_AUTO_TEST_CASE( EQUAL ) {
-    MessageCounterPtr logger(new MessageCounter());
+    CounterLogPtr logger(new CounterLog());
     EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
     std::shared_ptr<GridProperty<int> > pvtnum = state.getIntGridProperty("PVTNUM");
     std::shared_ptr<GridProperty<int> > eqlnum = state.getIntGridProperty("EQLNUM");
diff --git a/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp b/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
index de4e79fb3..3a10ccee3 100644
--- a/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
+++ b/opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(correctDeckString);
-        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
+        Opm::CounterLogPtr logger(new Opm::CounterLog());
         BOOST_CHECK(Opm::checkDeck(deck, logger));
     }
 
@@ -64,7 +64,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(correctDeckString);
-        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
+        Opm::CounterLogPtr logger(new Opm::CounterLog());
         BOOST_CHECK(!Opm::checkDeck(deck, logger));
         BOOST_CHECK(Opm::checkDeck(deck, logger, ~Opm::SectionTopology));
     }
@@ -91,7 +91,7 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
             "SCHEDULE\n";
 
         auto deck = parser->parseString(incorrectDeckString);
-        Opm::MessageCounterPtr logger(new Opm::MessageCounter());
+        Opm::CounterLogPtr logger(new Opm::CounterLog());
         BOOST_CHECK(!Opm::checkDeck(deck, logger));
 
         // this is supposed to succeed as we don't ensure that all keywords are in the
diff --git a/opm/parser/eclipse/OpmLog/MessageCounter.cpp b/opm/parser/eclipse/OpmLog/CounterLog.cpp
similarity index 76%
rename from opm/parser/eclipse/OpmLog/MessageCounter.cpp
rename to opm/parser/eclipse/OpmLog/CounterLog.cpp
index 6303de645..11b6fb74c 100644
--- a/opm/parser/eclipse/OpmLog/MessageCounter.cpp
+++ b/opm/parser/eclipse/OpmLog/CounterLog.cpp
@@ -22,12 +22,12 @@
 
 #include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
 #include <opm/parser/eclipse/OpmLog/LogUtil.hpp>
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 
 
 namespace Opm {
-MessageCounter::MessageCounter() : LogBackend(Log::DefaultMessageTypes)
+CounterLog::CounterLog() : LogBackend(Log::DefaultMessageTypes)
 {
     m_numErrors = 0;
     m_numWarnings = 0;
@@ -36,7 +36,7 @@ MessageCounter::MessageCounter() : LogBackend(Log::DefaultMessageTypes)
     setOutStream(NULL);
 }
 
-MessageCounter::MessageCounter(std::ostream* os) : LogBackend(Log::DefaultMessageTypes)
+CounterLog::CounterLog(std::ostream* os) : LogBackend(Log::DefaultMessageTypes)
 {
     m_numErrors = 0;
     m_numWarnings = 0;
@@ -45,27 +45,27 @@ MessageCounter::MessageCounter(std::ostream* os) : LogBackend(Log::DefaultMessag
     setOutStream(os);
 }
 
-void MessageCounter::setOutStream(std::ostream* os) {
+void CounterLog::setOutStream(std::ostream* os) {
     m_outStream = os;
 }
 
-size_t MessageCounter::size() const {
+size_t CounterLog::size() const {
     return m_messages.size();
 }
 
-size_t MessageCounter::numErrors() const {
+size_t CounterLog::numErrors() const {
     return m_numErrors;
 }
 
-size_t MessageCounter::numWarnings() const {
+size_t CounterLog::numWarnings() const {
     return m_numWarnings;
 }
 
-size_t MessageCounter::numNotes() const {
+size_t CounterLog::numNotes() const {
     return m_numNotes;
 }
 
-void MessageCounter::addMessage(const std::string& fileName,
+void CounterLog::addMessage(const std::string& fileName,
                                 int lineNumber,
                                 int64_t messageType,
                                 const std::string& description) {
@@ -97,7 +97,7 @@ void MessageCounter::addMessage(const std::string& fileName,
     }
 }
 
-void MessageCounter::addMessage(int64_t messageType , const std::string& message) {
+void CounterLog::addMessage(int64_t messageType , const std::string& message) {
     if (includeMessage( messageType ))
         addMessage("???" , -1 , messageType , message);
 }
@@ -105,26 +105,26 @@ void MessageCounter::addMessage(int64_t messageType , const std::string& message
 
 
 
-void MessageCounter::addNote(const std::string& fileName,
+void CounterLog::addNote(const std::string& fileName,
                              int lineNumber,
                              const std::string& description) {
     addMessage(fileName, lineNumber, Log::MessageType::Note, description);
 }
 
-void MessageCounter::addWarning(const std::string& fileName,
+void CounterLog::addWarning(const std::string& fileName,
                                 int lineNumber,
                                 const std::string& description) {
     addMessage(fileName, lineNumber, Log::MessageType::Warning, description);
 }
 
-void MessageCounter::addError(const std::string& fileName,
+void CounterLog::addError(const std::string& fileName,
                               int lineNumber,
                               const std::string& description) {
     addMessage(fileName, lineNumber, Log::MessageType::Error, description);
 }
 
 
-void MessageCounter::clear()
+void CounterLog::clear()
 {
     m_numErrors = 0;
     m_numWarnings = 0;
@@ -133,7 +133,7 @@ void MessageCounter::clear()
     m_messages.clear();
 }
 
-void MessageCounter::append(const MessageCounter &other)
+void CounterLog::append(const CounterLog &other)
 {
     for (size_t i = 0; i < other.size(); ++i) {
         addMessage(other.getFileName(i),
@@ -143,27 +143,27 @@ void MessageCounter::append(const MessageCounter &other)
     }
 }
 
-const std::string& MessageCounter::getFileName(size_t msgIdx) const {
+const std::string& CounterLog::getFileName(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<0>(m_messages[msgIdx]);
 }
 
-int MessageCounter::getLineNumber(size_t msgIdx) const {
+int CounterLog::getLineNumber(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<1>(m_messages[msgIdx]);
 }
 
-int64_t MessageCounter::getMessageType(size_t msgIdx) const {
+int64_t CounterLog::getMessageType(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<2>(m_messages[msgIdx]);
 }
 
-const std::string& MessageCounter::getDescription(size_t msgIdx) const {
+const std::string& CounterLog::getDescription(size_t msgIdx) const {
     assert(msgIdx < size());
     return std::get<3>(m_messages[msgIdx]);
 }
 
-const std::string MessageCounter::getFormattedMessage(size_t msgIdx) const {
+const std::string CounterLog::getFormattedMessage(size_t msgIdx) const {
     const std::string& description = getDescription( msgIdx );
     int64_t messageType = getMessageType( msgIdx );
     std::string prefixedMessage = Log::prefixMessage( messageType  , description);
@@ -178,7 +178,7 @@ const std::string MessageCounter::getFormattedMessage(size_t msgIdx) const {
 
 
 
-void MessageCounter::printAll(std::ostream& os, size_t enabledTypes) const {
+void CounterLog::printAll(std::ostream& os, size_t enabledTypes) const {
     for (size_t i = 0; i < size(); ++i)
         if (enabledTypes & getMessageType(i))
             os << getFormattedMessage(i) << "\n";
diff --git a/opm/parser/eclipse/OpmLog/MessageCounter.hpp b/opm/parser/eclipse/OpmLog/CounterLog.hpp
similarity index 89%
rename from opm/parser/eclipse/OpmLog/MessageCounter.hpp
rename to opm/parser/eclipse/OpmLog/CounterLog.hpp
index d8637fee4..263c08c16 100644
--- a/opm/parser/eclipse/OpmLog/MessageCounter.hpp
+++ b/opm/parser/eclipse/OpmLog/CounterLog.hpp
@@ -16,8 +16,8 @@
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef OPM_MESSAGECOUNTER_HPP
-#define OPM_MESSAGECOUNTER_HPP
+#ifndef OPM_COUNTERLOG_HPP
+#define OPM_COUNTERLOG_HPP
 
 #include <iostream>
 #include <string>
@@ -34,11 +34,11 @@ namespace Opm {
  * \brief Provides a simple sytem for log message which are found by the
  *        Parser/Deck/EclipseState classes during processing the deck.
  */
-    class MessageCounter : public LogBackend {
+    class CounterLog : public LogBackend {
 public:
 
-    MessageCounter();
-    MessageCounter(std::ostream* os);
+    CounterLog();
+    CounterLog(std::ostream* os);
 
     void setOutStream(std::ostream* os);
 
@@ -74,7 +74,7 @@ public:
     const std::string& getDescription(size_t msgIdx) const;
 
     void clear();
-    void append(const MessageCounter &other);
+    void append(const CounterLog &other);
 
     /*!
      * \brief This method takes the information provided by the methods above and returns
@@ -95,7 +95,7 @@ public:
      */
     void printAll(std::ostream &os = std::cerr,
                   size_t enabledTypes = Log::DefaultMessageTypes) const;
-    ~MessageCounter() {};
+    ~CounterLog() {};
 private:
     typedef std::tuple<std::string,
                        int,
@@ -110,8 +110,8 @@ private:
     mutable std::ostream* m_outStream;
 };
 
-typedef std::shared_ptr<MessageCounter> MessageCounterPtr;
-typedef std::shared_ptr<const MessageCounter> MessageCounterConstPtr;
+typedef std::shared_ptr<CounterLog> CounterLogPtr;
+typedef std::shared_ptr<const CounterLog> CounterLogConstPtr;
 } // namespace Opm
 
 #endif
diff --git a/opm/parser/eclipse/OpmLog/tests/OpmLogTests.cpp b/opm/parser/eclipse/OpmLog/tests/OpmLogTests.cpp
index 0157313a7..7ca612651 100644
--- a/opm/parser/eclipse/OpmLog/tests/OpmLogTests.cpp
+++ b/opm/parser/eclipse/OpmLog/tests/OpmLogTests.cpp
@@ -27,7 +27,7 @@
 #include <boost/test/unit_test.hpp>
 #include <opm/parser/eclipse/OpmLog/OpmLog.hpp>
 #include <opm/parser/eclipse/OpmLog/LogBackend.hpp>
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 #include <opm/parser/eclipse/OpmLog/StreamLog.hpp>
 #include <opm/parser/eclipse/OpmLog/LogUtil.hpp>
 
@@ -70,7 +70,7 @@ BOOST_AUTO_TEST_CASE(Test_AbstractBackend) {
 BOOST_AUTO_TEST_CASE(Test_Logger) {
     Logger logger;
     std::ostringstream log_stream;
-    std::shared_ptr<MessageCounter> counter = std::make_shared<MessageCounter>();
+    std::shared_ptr<CounterLog> counter = std::make_shared<CounterLog>();
     std::shared_ptr<StreamLog> streamLog = std::make_shared<StreamLog>( log_stream , Log::MessageType::Warning );
     BOOST_CHECK_EQUAL( false , logger.hasBackend("NO"));
 
@@ -90,7 +90,7 @@ BOOST_AUTO_TEST_CASE(Test_Logger) {
 
     BOOST_CHECK_THROW( logger.getBackend<LogBackend>("No") , std::invalid_argument );
     {
-        auto counter2 = logger.getBackend<MessageCounter>("COUNTER");
+        auto counter2 = logger.getBackend<CounterLog>("COUNTER");
         BOOST_CHECK_EQUAL( 1U , counter2->numWarnings() );
         BOOST_CHECK_EQUAL( 1U , counter2->numErrors() );
         BOOST_CHECK_EQUAL( 0U , counter2->numNotes() );
@@ -121,7 +121,7 @@ BOOST_AUTO_TEST_CASE(LoggerDefaultTypesEnabled) {
 /*****************************************************************/
 
 void initLogger(std::ostringstream& log_stream) {
-    std::shared_ptr<MessageCounter> counter = std::make_shared<MessageCounter>();
+    std::shared_ptr<CounterLog> counter = std::make_shared<CounterLog>();
     std::shared_ptr<StreamLog> streamLog = std::make_shared<StreamLog>( log_stream , Log::MessageType::Warning );
 
     BOOST_CHECK_EQUAL( false , OpmLog::hasBackend("NO"));
@@ -143,7 +143,7 @@ BOOST_AUTO_TEST_CASE(TestOpmLog) {
     OpmLog::addMessage( Log::MessageType::Error , "Error");
 
     {
-        auto counter = OpmLog::getBackend<MessageCounter>("COUNTER");
+        auto counter = OpmLog::getBackend<CounterLog>("COUNTER");
 
         BOOST_CHECK_EQUAL( 1 , counter->numWarnings() );
         BOOST_CHECK_EQUAL( 1 , counter->numErrors() );
diff --git a/opm/parser/eclipse/Parser/Parser.cpp b/opm/parser/eclipse/Parser/Parser.cpp
index f62ccf6e3..7d19dae2f 100644
--- a/opm/parser/eclipse/Parser/Parser.cpp
+++ b/opm/parser/eclipse/Parser/Parser.cpp
@@ -19,7 +19,7 @@
 
 #include <memory>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/Parser/ParserIntItem.hpp>
 #include <opm/parser/eclipse/Parser/Parser.hpp>
@@ -33,7 +33,7 @@ namespace Opm {
 
     struct ParserState {
         DeckPtr deck;
-        MessageCounter logger;
+        CounterLog logger;
         boost::filesystem::path dataFile;
         boost::filesystem::path rootPath;
         std::map<std::string, std::string> pathMap;
@@ -91,7 +91,7 @@ namespace Opm {
      is retained in the current implementation.
      */
 
-    DeckPtr Parser::parseFile(const std::string &dataFileName, MessageCounterPtr logger) const {
+    DeckPtr Parser::parseFile(const std::string &dataFileName, CounterLogPtr logger) const {
 
         std::shared_ptr<ParserState> parserState(new ParserState(dataFileName, DeckPtr(new Deck()), getRootPathFromFile(dataFileName)));
 
@@ -108,7 +108,7 @@ namespace Opm {
         return parserState->deck;
     }
 
-    DeckPtr Parser::parseString(const std::string &data, MessageCounterPtr logger) const {
+    DeckPtr Parser::parseString(const std::string &data, CounterLogPtr logger) const {
 
         std::shared_ptr<ParserState> parserState(new ParserState(data, DeckPtr(new Deck())));
 
@@ -121,7 +121,7 @@ namespace Opm {
         return parserState->deck;
     }
 
-    DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, MessageCounterPtr logger) const {
+    DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, CounterLogPtr logger) const {
         std::shared_ptr<ParserState> parserState(new ParserState(inputStream, DeckPtr(new Deck())));
 
         parseState(parserState);
diff --git a/opm/parser/eclipse/Parser/Parser.hpp b/opm/parser/eclipse/Parser/Parser.hpp
index 857961b10..c202de19d 100644
--- a/opm/parser/eclipse/Parser/Parser.hpp
+++ b/opm/parser/eclipse/Parser/Parser.hpp
@@ -29,7 +29,7 @@
 
 #include <opm/json/JsonObject.hpp>
 
-#include <opm/parser/eclipse/OpmLog/MessageCounter.hpp>
+#include <opm/parser/eclipse/OpmLog/CounterLog.hpp>
 
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
@@ -48,9 +48,9 @@ namespace Opm {
         Parser(bool addDefault = true);
 
         /// The starting point of the parsing process. The supplied file is parsed, and the resulting Deck is returned.
-        DeckPtr parseFile(const std::string &dataFile, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
-        DeckPtr parseString(const std::string &data, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
-        DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, MessageCounterPtr logger = std::make_shared<MessageCounter>(&std::cout)) const;
+        DeckPtr parseFile(const std::string &dataFile, CounterLogPtr logger = std::make_shared<CounterLog>(&std::cout)) const;
+        DeckPtr parseString(const std::string &data, CounterLogPtr logger = std::make_shared<CounterLog>(&std::cout)) const;
+        DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, CounterLogPtr logger = std::make_shared<CounterLog>(&std::cout)) const;
 
         /// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
         void addParserKeyword(ParserKeywordConstPtr parserKeyword);