diff --git a/src/dagre-wrapper/clusters.js b/src/dagre-wrapper/clusters.js
index 283bfdafb..87a6e2a5c 100644
--- a/src/dagre-wrapper/clusters.js
+++ b/src/dagre-wrapper/clusters.js
@@ -1,11 +1,11 @@
 import intersectRect from './intersect/intersect-rect';
-import { logger as log } from '../logger'; // eslint-disable-line
+import { logger } from '../logger'; // eslint-disable-line
 import createLabel from './createLabel';
 import { select } from 'd3';
 import { getConfig } from '../config';
 
 const rect = (parent, node) => {
-  log.trace('Creating subgraph rect for ', node.id, node);
+  logger.trace('Creating subgraph rect for ', node.id, node);
 
   // Add outer g element
   const shapeSvg = parent
@@ -37,7 +37,7 @@ const rect = (parent, node) => {
   const padding = 0 * node.padding;
   const halfPadding = padding / 2;
 
-  log.trace('Data ', node, JSON.stringify(node));
+  logger.trace('Data ', node, JSON.stringify(node));
   // center the rect around its coordinate
   rect
     .attr('style', node.style)
@@ -208,7 +208,7 @@ const shapes = { rect, roundedWithTitle, noteGroup, divider };
 let clusterElems = {};
 
 export const insertCluster = (elem, node) => {
-  log.trace('Inserting cluster');
+  logger.trace('Inserting cluster');
   const shape = node.shape || 'rect';
   clusterElems[node.id] = shapes[shape](elem, node);
 };
@@ -225,7 +225,7 @@ export const clear = () => {
 };
 
 export const positionCluster = node => {
-  log.info('Position cluster');
+  logger.info('Position cluster');
   const el = clusterElems[node.id];
 
   el.attr('transform', 'translate(' + node.x + ', ' + node.y + ')');
diff --git a/src/dagre-wrapper/index.js b/src/dagre-wrapper/index.js
index 1e6e4d249..7ebfc4b20 100644
--- a/src/dagre-wrapper/index.js
+++ b/src/dagre-wrapper/index.js
@@ -12,21 +12,21 @@ import {
 import { insertNode, positionNode, clear as clearNodes, setNodeElem } from './nodes';
 import { insertCluster, clear as clearClusters } from './clusters';
 import { insertEdgeLabel, positionEdgeLabel, insertEdge, clear as clearEdges } from './edges';
-import { logger as log } from '../logger';
+import { logger } from '../logger';
 
 const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
-  log.info('Graph in recursive render: XXX', graphlib.json.write(graph), parentCluster);
+  logger.info('Graph in recursive render: XXX', graphlib.json.write(graph), parentCluster);
   const dir = graph.graph().rankdir;
-  log.warn('Dir in recursive render - dir:', dir);
+  logger.warn('Dir in recursive render - dir:', dir);
 
   const elem = _elem.insert('g').attr('class', 'root'); // eslint-disable-line
   if (!graph.nodes()) {
-    log.info('No nodes found for', graph);
+    logger.info('No nodes found for', graph);
   } else {
-    log.info('Recursive render XXX', graph.nodes());
+    logger.info('Recursive render XXX', graph.nodes());
   }
   if (graph.edges().length > 0) {
-    log.info('Recursive edges', graph.edge(graph.edges()[0]));
+    logger.info('Recursive edges', graph.edge(graph.edges()[0]));
   }
   const clusters = elem.insert('g').attr('class', 'clusters'); // eslint-disable-line
   const edgePaths = elem.insert('g').attr('class', 'edgePaths');
@@ -40,32 +40,32 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
     if (typeof parentCluster !== 'undefined') {
       const data = JSON.parse(JSON.stringify(parentCluster.clusterData));
       // data.clusterPositioning = true;
-      log.info('Setting data for cluster XXX (', v, ') ', data, parentCluster);
+      logger.info('Setting data for cluster XXX (', v, ') ', data, parentCluster);
       graph.setNode(parentCluster.id, data);
       if (!graph.parent(v)) {
-        log.warn('Setting parent', v, parentCluster.id);
+        logger.warn('Setting parent', v, parentCluster.id);
         graph.setParent(v, parentCluster.id, data);
       }
     }
-    log.info('(Insert) Node XXX' + v + ': ' + JSON.stringify(graph.node(v)));
+    logger.info('(Insert) Node XXX' + v + ': ' + JSON.stringify(graph.node(v)));
     if (node && node.clusterNode) {
       // const children = graph.children(v);
-      log.info('Cluster identified', v, node, graph.node(v));
+      logger.info('Cluster identified', v, node, graph.node(v));
       const newEl = recursiveRender(nodes, node.graph, diagramtype, graph.node(v));
       updateNodeBounds(node, newEl);
       setNodeElem(newEl, node);
 
-      log.warn('Recursive render complete', newEl, node);
+      logger.warn('Recursive render complete', newEl, node);
     } else {
       if (graph.children(v).length > 0) {
         // This is a cluster but not to be rendered recusively
         // Render as before
-        log.info('Cluster - the non recursive path XXX', v, node.id, node, graph);
-        log.info(findNonClusterChild(node.id, graph));
+        logger.info('Cluster - the non recursive path XXX', v, node.id, node, graph);
+        logger.info(findNonClusterChild(node.id, graph));
         clusterDb[node.id] = { id: findNonClusterChild(node.id, graph), node };
         // insertCluster(clusters, graph.node(v));
       } else {
-        log.info('Node - the non recursive path', v, node.id, node);
+        logger.info('Node - the non recursive path', v, node.id, node);
         insertNode(nodes, graph.node(v), dir);
       }
     }
@@ -77,28 +77,28 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
   // TODO: pick optimal child in the cluster to us as link anchor
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e.v, e.w, e.name);
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ', e, ' ', JSON.stringify(graph.edge(e)));
 
     // Check if link is either from or to a cluster
-    log.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
+    logger.info('Fix', clusterDb, 'ids:', e.v, e.w, 'Translateing: ', clusterDb[e.v], clusterDb[e.w]);
     insertEdgeLabel(edgeLabels, edge);
   });
 
   graph.edges().forEach(function(e) {
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
   });
-  log.info('#############################################');
-  log.info('###                Layout                 ###');
-  log.info('#############################################');
-  log.info(graph);
+  logger.info('#############################################');
+  logger.info('###                Layout                 ###');
+  logger.info('#############################################');
+  logger.info(graph);
   dagre.layout(graph);
-  log.info('Graph after layout:', graphlib.json.write(graph));
+  logger.info('Graph after layout:', graphlib.json.write(graph));
   // Move the nodes to the correct place
   sortNodesByHierarchy(graph).forEach(function(v) {
     const node = graph.node(v);
-    log.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
-    log.info(
+    logger.info('Position ' + v + ': ' + JSON.stringify(graph.node(v)));
+    logger.info(
       'Position ' + v + ': (' + node.x,
       ',' + node.y,
       ') width: ',
@@ -126,7 +126,7 @@ const recursiveRender = (_elem, graph, diagramtype, parentCluster) => {
   // Move the edge labels to the correct place after layout
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    log.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
+    logger.info('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(edge), edge);
 
     const paths = insertEdge(edgePaths, e, edge, clusterDb, diagramtype, graph);
     positionEdgeLabel(edge, paths);
@@ -142,10 +142,10 @@ export const render = (elem, graph, markers, diagramtype, id) => {
   clearClusters();
   clearGraphlib();
 
-  log.warn('Graph at first:', graphlib.json.write(graph));
+  logger.warn('Graph at first:', graphlib.json.write(graph));
   adjustClustersAndEdges(graph);
-  log.warn('Graph after:', graphlib.json.write(graph));
-  // log.warn('Graph ever  after:', graphlib.json.write(graph.node('A').graph));
+  logger.warn('Graph after:', graphlib.json.write(graph));
+  // logger.warn('Graph ever  after:', graphlib.json.write(graph.node('A').graph));
   recursiveRender(elem, graph, diagramtype);
 };
 
diff --git a/src/dagre-wrapper/mermaid-graphlib.js b/src/dagre-wrapper/mermaid-graphlib.js
index 6aa1af7f8..39b1e0e14 100644
--- a/src/dagre-wrapper/mermaid-graphlib.js
+++ b/src/dagre-wrapper/mermaid-graphlib.js
@@ -1,7 +1,7 @@
 /**
  * Decorates with functions required by mermaids dagre-wrapper.
  */
-import { logger as log } from '../logger';
+import { logger } from '../logger';
 import graphlib from 'graphlib';
 
 export let clusterDb = {};
@@ -17,7 +17,7 @@ export const clear = () => {
 const isDecendant = (id, ancenstorId) => {
   // if (id === ancenstorId) return true;
 
-  log.debug(
+  logger.debug(
     'In isDecendant',
     ancenstorId,
     ' ',
@@ -31,17 +31,17 @@ const isDecendant = (id, ancenstorId) => {
 };
 
 const edgeInCluster = (edge, clusterId) => {
-  log.info('Decendants of ', clusterId, ' is ', decendants[clusterId]);
-  log.info('Edge is ', edge);
+  logger.info('Decendants of ', clusterId, ' is ', decendants[clusterId]);
+  logger.info('Edge is ', edge);
   // Edges to/from the cluster is not in the cluster, they are in the parent
   if (edge.v === clusterId) return false;
   if (edge.w === clusterId) return false;
 
   if (!decendants[clusterId]) {
-    log.debug('Tilt, ', clusterId, ',not in decendants');
+    logger.debug('Tilt, ', clusterId, ',not in decendants');
     return false;
   }
-  log.info('Here ');
+  logger.info('Here ');
 
   if (decendants[clusterId].indexOf(edge.v) >= 0) return true;
   if (isDecendant(edge.v, clusterId)) return true;
@@ -52,7 +52,7 @@ const edgeInCluster = (edge, clusterId) => {
 };
 
 const copy = (clusterId, graph, newGraph, rootId) => {
-  log.warn(
+  logger.warn(
     'Copying children of ',
     clusterId,
     'root',
@@ -68,26 +68,26 @@ const copy = (clusterId, graph, newGraph, rootId) => {
     nodes.push(clusterId);
   }
 
-  log.warn('Copying (nodes) clusterId', clusterId, 'nodes', nodes);
+  logger.warn('Copying (nodes) clusterId', clusterId, 'nodes', nodes);
 
   nodes.forEach(node => {
     if (graph.children(node).length > 0) {
       copy(node, graph, newGraph, rootId);
     } else {
       const data = graph.node(node);
-      log.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
+      logger.info('cp ', node, ' to ', rootId, ' with parent ', clusterId); //,node, data, ' parent is ', clusterId);
       newGraph.setNode(node, data);
       if (rootId !== graph.parent(node)) {
-        log.warn('Setting parent', node, graph.parent(node));
+        logger.warn('Setting parent', node, graph.parent(node));
         newGraph.setParent(node, graph.parent(node));
       }
 
       if (clusterId !== rootId && node !== clusterId) {
-        log.debug('Setting parent', node, clusterId);
+        logger.debug('Setting parent', node, clusterId);
         newGraph.setParent(node, clusterId);
       } else {
-        log.info('In copy ', clusterId, 'root', rootId, 'data', graph.node(clusterId), rootId);
-        log.debug(
+        logger.info('In copy ', clusterId, 'root', rootId, 'data', graph.node(clusterId), rootId);
+        logger.debug(
           'Not Setting parent for node=',
           node,
           'cluster!==rootId',
@@ -97,19 +97,19 @@ const copy = (clusterId, graph, newGraph, rootId) => {
         );
       }
       const edges = graph.edges(node);
-      log.debug('Copying Edges', edges);
+      logger.debug('Copying Edges', edges);
       edges.forEach(edge => {
-        log.info('Edge', edge);
+        logger.info('Edge', edge);
         const data = graph.edge(edge.v, edge.w, edge.name);
-        log.info('Edge data', data, rootId);
+        logger.info('Edge data', data, rootId);
         try {
           // Do not copy edges in and out of the root cluster, they belong to the parent graph
           if (edgeInCluster(edge, rootId)) {
-            log.info('Copying as ', edge.v, edge.w, data, edge.name);
+            logger.info('Copying as ', edge.v, edge.w, data, edge.name);
             newGraph.setEdge(edge.v, edge.w, data, edge.name);
-            log.info('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
+            logger.info('newGraph edges ', newGraph.edges(), newGraph.edge(newGraph.edges()[0]));
           } else {
-            log.info(
+            logger.info(
               'Skipping copy of edge ',
               edge.v,
               '-->',
@@ -121,16 +121,16 @@ const copy = (clusterId, graph, newGraph, rootId) => {
             );
           }
         } catch (e) {
-          log.error(e);
+          logger.error(e);
         }
       });
     }
-    log.debug('Removing node', node);
+    logger.debug('Removing node', node);
     graph.removeNode(node);
   });
 };
 export const extractDecendants = (id, graph) => {
-  // log.debug('Extracting ', id);
+  // logger.debug('Extracting ', id);
   const children = graph.children(id);
   let res = [].concat(children);
 
@@ -149,14 +149,14 @@ export const extractDecendants = (id, graph) => {
  */
 export const validate = graph => {
   const edges = graph.edges();
-  log.trace('Edges: ', edges);
+  logger.trace('Edges: ', edges);
   for (let i = 0; i < edges.length; i++) {
     if (graph.children(edges[i].v).length > 0) {
-      log.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
+      logger.trace('The node ', edges[i].v, ' is part of and edge even though it has children');
       return false;
     }
     if (graph.children(edges[i].w).length > 0) {
-      log.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
+      logger.trace('The node ', edges[i].w, ' is part of and edge even though it has children');
       return false;
     }
   }
@@ -170,18 +170,18 @@ export const validate = graph => {
  */
 export const findNonClusterChild = (id, graph) => {
   // const node = graph.node(id);
-  log.trace('Searching', id);
+  logger.trace('Searching', id);
   // const children = graph.children(id).reverse();
   const children = graph.children(id); //.reverse();
-  log.trace('Searching children of id ', id, children);
+  logger.trace('Searching children of id ', id, children);
   if (children.length < 1) {
-    log.trace('This is a valid node', id);
+    logger.trace('This is a valid node', id);
     return id;
   }
   for (let i = 0; i < children.length; i++) {
     const _id = findNonClusterChild(children[i], graph);
     if (_id) {
-      log.trace('Found replacement for', id, ' => ', _id);
+      logger.trace('Found replacement for', id, ' => ', _id);
       return _id;
     }
   }
@@ -205,17 +205,17 @@ const getAnchorId = id => {
 
 export const adjustClustersAndEdges = (graph, depth) => {
   if (!graph || depth > 10) {
-    log.debug('Opting out, no graph ');
+    logger.debug('Opting out, no graph ');
     return;
   } else {
-    log.debug('Opting in, graph ');
+    logger.debug('Opting in, graph ');
   }
   // Go through the nodes and for each cluster found, save a replacment node, this can be used when
   // faking a link to a cluster
   graph.nodes().forEach(function(id) {
     const children = graph.children(id);
     if (children.length > 0) {
-      log.warn(
+      logger.warn(
         'Cluster identified',
         id,
         ' Replacement id in edges: ',
@@ -231,9 +231,9 @@ export const adjustClustersAndEdges = (graph, depth) => {
     const children = graph.children(id);
     const edges = graph.edges();
     if (children.length > 0) {
-      log.debug('Cluster identified', id, decendants);
+      logger.debug('Cluster identified', id, decendants);
       edges.forEach(edge => {
-        // log.debug('Edge, decendants: ', edge, decendants[id]);
+        // logger.debug('Edge, decendants: ', edge, decendants[id]);
 
         // Check if any edge leaves the cluster (not the actual cluster, thats a link from the box)
         if (edge.v !== id && edge.w !== id) {
@@ -245,14 +245,14 @@ export const adjustClustersAndEdges = (graph, depth) => {
 
           // d1 xor d2 - if either d1 is true and d2 is false or the other way around
           if (d1 ^ d2) {
-            log.warn('Edge: ', edge, ' leaves cluster ', id);
-            log.warn('Decendants of XXX ', id, ': ', decendants[id]);
+            logger.warn('Edge: ', edge, ' leaves cluster ', id);
+            logger.warn('Decendants of XXX ', id, ': ', decendants[id]);
             clusterDb[id].externalConnections = true;
           }
         }
       });
     } else {
-      log.debug('Not a cluster ', id, decendants);
+      logger.debug('Not a cluster ', id, decendants);
     }
   });
 
@@ -260,13 +260,13 @@ export const adjustClustersAndEdges = (graph, depth) => {
   // in the cluster inorder to fake the edge
   graph.edges().forEach(function(e) {
     const edge = graph.edge(e);
-    log.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
-    log.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
+    logger.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(e));
+    logger.warn('Edge ' + e.v + ' -> ' + e.w + ': ' + JSON.stringify(graph.edge(e)));
 
     let v = e.v;
     let w = e.w;
     // Check if link is either from or to a cluster
-    log.warn(
+    logger.warn(
       'Fix XXX',
       clusterDb,
       'ids:',
@@ -278,20 +278,20 @@ export const adjustClustersAndEdges = (graph, depth) => {
       clusterDb[e.w]
     );
     if (clusterDb[e.v] || clusterDb[e.w]) {
-      log.warn('Fixing and trixing - removing XXX', e.v, e.w, e.name);
+      logger.warn('Fixing and trixing - removing XXX', e.v, e.w, e.name);
       v = getAnchorId(e.v);
       w = getAnchorId(e.w);
       graph.removeEdge(e.v, e.w, e.name);
       if (v !== e.v) edge.fromCluster = e.v;
       if (w !== e.w) edge.toCluster = e.w;
-      log.warn('Fix Replacing with XXX', v, w, e.name);
+      logger.warn('Fix Replacing with XXX', v, w, e.name);
       graph.setEdge(v, w, edge, e.name);
     }
   });
-  log.warn('Adjusted Graph', graphlib.json.write(graph));
+  logger.warn('Adjusted Graph', graphlib.json.write(graph));
   extractor(graph, 0);
 
-  log.trace(clusterDb);
+  logger.trace(clusterDb);
 
   // Remove references to extracted cluster
   // graph.edges().forEach(edge => {
@@ -302,9 +302,9 @@ export const adjustClustersAndEdges = (graph, depth) => {
 };
 
 export const extractor = (graph, depth) => {
-  log.warn('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
+  logger.warn('extractor - ', depth, graphlib.json.write(graph), graph.children('D'));
   if (depth > 10) {
-    log.error('Bailing out');
+    logger.error('Bailing out');
     return;
   }
   // For clusters without incoming and/or outgoing edges, create a new cluster-node
@@ -319,16 +319,16 @@ export const extractor = (graph, depth) => {
   }
 
   if (!hasChildren) {
-    log.debug('Done, no node has children', graph.nodes());
+    logger.debug('Done, no node has children', graph.nodes());
     return;
   }
   // const clusters = Object.keys(clusterDb);
   // clusters.forEach(clusterId => {
-  log.debug('Nodes = ', nodes, depth);
+  logger.debug('Nodes = ', nodes, depth);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
 
-    log.debug(
+    logger.debug(
       'Extracting node',
       node,
       clusterDb,
@@ -343,7 +343,7 @@ export const extractor = (graph, depth) => {
     // that it still is in the game
     if (!clusterDb[node]) {
       // Skip if the node is not a cluster
-      log.debug('Not a cluster', node, depth);
+      logger.debug('Not a cluster', node, depth);
       // break;
     } else if (
       !clusterDb[node].externalConnections &&
@@ -351,7 +351,7 @@ export const extractor = (graph, depth) => {
       graph.children(node) &&
       graph.children(node).length > 0
     ) {
-      log.warn(
+      logger.warn(
         'Cluster without external connections, without a parent and with children',
         node,
         depth
@@ -375,7 +375,7 @@ export const extractor = (graph, depth) => {
           return {};
         });
 
-      log.warn('Old graph before copy', graphlib.json.write(graph));
+      logger.warn('Old graph before copy', graphlib.json.write(graph));
       copy(node, graph, clusterGraph, node);
       graph.setNode(node, {
         clusterNode: true,
@@ -384,10 +384,10 @@ export const extractor = (graph, depth) => {
         labelText: clusterDb[node].labelText,
         graph: clusterGraph
       });
-      log.warn('New graph after copy node: (', node, ')', graphlib.json.write(clusterGraph));
-      log.debug('Old graph after copy', graphlib.json.write(graph));
+      logger.warn('New graph after copy node: (', node, ')', graphlib.json.write(clusterGraph));
+      logger.debug('Old graph after copy', graphlib.json.write(graph));
     } else {
-      log.warn(
+      logger.warn(
         'Cluster ** ',
         node,
         ' **not meeting the criteria !externalConnections:',
@@ -399,16 +399,16 @@ export const extractor = (graph, depth) => {
         graph.children('D'),
         depth
       );
-      log.debug(clusterDb);
+      logger.debug(clusterDb);
     }
   }
 
   nodes = graph.nodes();
-  log.warn('New list of nodes', nodes);
+  logger.warn('New list of nodes', nodes);
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const data = graph.node(node);
-    log.warn(' Now next level', node, data);
+    logger.warn(' Now next level', node, data);
     if (data.clusterNode) {
       extractor(data.graph, depth + 1);
     }