diff --git a/chameleon/grpc_client/grpc_client.py b/chameleon/grpc_client/grpc_client.py
index 234f24a..7d43384 100644
--- a/chameleon/grpc_client/grpc_client.py
+++ b/chameleon/grpc_client/grpc_client.py
@@ -33,11 +33,11 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 from werkzeug.exceptions import ServiceUnavailable
 
-from common.utils.asleep import asleep
 from chameleon.protos import third_party
 from chameleon.protos.schema_pb2 import SchemaServiceStub
 from google.protobuf.empty_pb2 import Empty
 
+from chameleon.utils.asleep import asleep
 
 log = get_logger()
 
diff --git a/chameleon/main.py b/chameleon/main.py
index 7d06efe..9c5912c 100755
--- a/chameleon/main.py
+++ b/chameleon/main.py
@@ -24,15 +24,16 @@
 import yaml
 from twisted.internet.defer import inlineCallbacks
 
+from chameleon.utils.dockerhelpers import get_my_containers_name
+from chameleon.utils.nethelpers import get_my_primary_local_ipv4
+from chameleon.utils.structlog_setup import setup_logging
+
 base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(base_dir)
 sys.path.append(os.path.join(base_dir, '/chameleon/protos/third_party'))
 
 from chameleon.grpc_client.grpc_client import GrpcClient
 from chameleon.web_server.web_server import WebServer
-from common.utils.dockerhelpers import get_my_containers_name
-from common.utils.nethelpers import get_my_primary_local_ipv4
-from common.structlog_setup import setup_logging
 
 
 defs = dict(
diff --git a/chameleon/utils/__init__.py b/chameleon/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/chameleon/utils/__init__.py
diff --git a/chameleon/utils/asleep.py b/chameleon/utils/asleep.py
new file mode 100644
index 0000000..295f675
--- /dev/null
+++ b/chameleon/utils/asleep.py
@@ -0,0 +1,28 @@
+#
+# Copyright 2017 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from twisted.internet import reactor
+from twisted.internet.defer import Deferred
+
+
+def asleep(dt):
+    """
+    Async (event driven) wait for given time period (in seconds)
+    :param dt: Delay in seconds
+    :return: Deferred to be fired with value None when time expires.
+    """
+    d = Deferred()
+    reactor.callLater(dt, lambda: d.callback(None))
+    return d
\ No newline at end of file
diff --git a/chameleon/utils/dockerhelpers.py b/chameleon/utils/dockerhelpers.py
new file mode 100644
index 0000000..2961e37
--- /dev/null
+++ b/chameleon/utils/dockerhelpers.py
@@ -0,0 +1,45 @@
+#
+# Copyright 2017 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import os
+
+from docker import Client
+from structlog import get_logger
+
+docker_socket = os.environ.get('DOCKER_SOCK', 'unix://tmp/docker.sock')
+log = get_logger()
+
+
+def get_my_containers_name():
+    """
+    Return the docker containers name in which this process is running.
+    To look up the container name, we use the container ID extracted from the
+    $HOSTNAME environment variable (which is set by docker conventions).
+    :return: String with the docker container name (or None if any issue is
+             encountered)
+    """
+    my_container_id = os.environ.get('HOSTNAME', None)
+
+    try:
+        docker_cli = Client(base_url=docker_socket)
+        info = docker_cli.inspect_container(my_container_id)
+
+    except Exception, e:
+        log.exception('failed', my_container_id=my_container_id, e=e)
+        raise
+
+    name = info['Name'].lstrip('/')
+
+    return name
\ No newline at end of file
diff --git a/chameleon/utils/nethelpers.py b/chameleon/utils/nethelpers.py
new file mode 100644
index 0000000..16a57c7
--- /dev/null
+++ b/chameleon/utils/nethelpers.py
@@ -0,0 +1,46 @@
+#
+# Copyright 2017 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Some network related convenience functions
+"""
+
+from netifaces import AF_INET
+
+import netifaces as ni
+
+
+def get_my_primary_interface():
+    gateways = ni.gateways()
+    assert 'default' in gateways, \
+        ("No default gateway on host/container, "
+         "cannot determine primary interface")
+    default_gw_index = gateways['default'].keys()[0]
+    # gateways[default_gw_index] has the format (example):
+    # [('10.15.32.1', 'en0', True)]
+    interface_name = gateways[default_gw_index][0][1]
+    return interface_name
+
+
+def get_my_primary_local_ipv4(ifname=None):
+    ifname = get_my_primary_interface() if ifname is None else ifname
+    addresses = ni.ifaddresses(ifname)
+    ipv4 = addresses[AF_INET][0]['addr']
+    return ipv4
+
+
+if __name__ == '__main__':
+    print get_my_primary_local_ipv4()
\ No newline at end of file
diff --git a/chameleon/utils/structlog_setup.py b/chameleon/utils/structlog_setup.py
new file mode 100644
index 0000000..6a149c0
--- /dev/null
+++ b/chameleon/utils/structlog_setup.py
@@ -0,0 +1,113 @@
+#
+# Copyright 2017 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Setting up proper logging for Voltha"""
+
+import logging
+import logging.config
+from collections import OrderedDict
+
+import structlog
+from structlog.stdlib import BoundLogger, INFO
+
+try:
+    from thread import get_ident as _get_ident
+except ImportError:
+    from dummy_thread import get_ident as _get_ident
+
+
+class FluentRenderer(object):
+    def __call__(self, logger, name, event_dict):
+        # in order to keep structured log data in event_dict to be forwarded as
+        # is to the fluent logger, we need to pass it into the logger framework
+        # as the first positional argument.
+        args = (event_dict, )
+        kwargs = {}
+        return args, kwargs
+
+
+class PlainRenderedOrderedDict(OrderedDict):
+    """Our special version of OrderedDict that renders into string as a dict,
+       to make the log stream output cleaner.
+    """
+    def __repr__(self, _repr_running={}):
+        'od.__repr__() <==> repr(od)'
+        call_key = id(self), _get_ident()
+        if call_key in _repr_running:
+            return '...'
+        _repr_running[call_key] = 1
+        try:
+            if not self:
+                return '{}'
+            return '{%s}' % ", ".join("%s: %s" % (k, v)
+                                      for k, v in self.items())
+        finally:
+            del _repr_running[call_key]
+
+
+def setup_logging(log_config, instance_id, verbosity_adjust=0, fluentd=None):
+    """
+    Set up logging such that:
+    - The primary logging entry method is structlog
+      (see http://structlog.readthedocs.io/en/stable/index.html)
+    - By default, the logging backend is Python standard lib logger
+    - Alternatively, fluentd can be configured with to be the backend,
+      providing direct bridge to a fluent logging agent.
+    """
+
+    def add_exc_info_flag_for_exception(_, name, event_dict):
+        if name == 'exception':
+            event_dict['exc_info'] = True
+        return event_dict
+
+    def add_instance_id(_, __, event_dict):
+        event_dict['instance_id'] = instance_id
+        return event_dict
+
+    # if fluentd is specified, we need to override the config data with
+    # its host and port info
+    if fluentd is not None:
+        fluentd_host = fluentd.split(':')[0].strip()
+        fluentd_port = int(fluentd.split(':')[1].strip())
+
+        handlers = log_config.get('handlers', None)
+        if isinstance(handlers, dict):
+            for _, defs in handlers.iteritems():
+                if isinstance(defs, dict):
+                    if defs.get('class', '').endswith('FluentHandler'):
+                        defs['host'] = fluentd_host
+                        defs['port'] = fluentd_port
+
+    # Configure standard logging
+    logging.config.dictConfig(log_config)
+    logging.root.level -= 10 * verbosity_adjust
+
+    processors = [
+        add_exc_info_flag_for_exception,
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        add_instance_id,
+        FluentRenderer(),
+    ]
+    structlog.configure(logger_factory=structlog.stdlib.LoggerFactory(),
+                        context_class=PlainRenderedOrderedDict,
+                        wrapper_class=BoundLogger,
+                        processors=processors)
+
+    # Mark first line of log
+    log = structlog.get_logger()
+    log.info("first-line")
+    return log
diff --git a/docker/Dockerfile.chameleon b/docker/Dockerfile.chameleon
index d2d1030..3b2f483 100644
--- a/docker/Dockerfile.chameleon
+++ b/docker/Dockerfile.chameleon
@@ -37,7 +37,6 @@
 # Bundle app source
 RUN mkdir /chameleon && touch /chameleon/__init__.py
 ENV PYTHONPATH=/chameleon
-COPY common /chameleon/common
 COPY chameleon /chameleon/chameleon
 
 # Exposing process and default entry point