--- a/testing/mozbase/mozlog/mozlog/commandline.py
+++ b/testing/mozbase/mozlog/mozlog/commandline.py
@@ -119,17 +119,17 @@ def add_logging_group(parser, include_fo
                                that is not related to test harnesses.
     """
     group_name = "Output Logging"
     group_description = ("Each option represents a possible logging format "
                          "and takes a filename to write that format to, "
                          "or '-' to write to stdout.")
 
     if include_formatters is None:
-        include_formatters = log_formatters.keys()
+        include_formatters = list(log_formatters.keys())
 
     if isinstance(parser, optparse.OptionParser):
         group = optparse.OptionGroup(parser,
                                      group_name,
                                      group_description)
         parser.add_option_group(group)
         opt_log_type = 'str'
         group_add = group.add_option

--- a/testing/mozbase/mozlog/mozlog/formatters/errorsummary.py
+++ b/testing/mozbase/mozlog/mozlog/formatters/errorsummary.py
@@ -33,17 +33,17 @@ class ErrorSummaryFormatter(BaseFormatte
                 "status": item["status"],
                 "expected": item["expected"],
                 "message": item.get("message"),
                 "stack": item.get("stack")}
         return self._output("test_result", data)
 
     def suite_start(self, item):
         self.groups = {v: k for k in item["tests"] for v in item["tests"][k]}
-        return self._output("test_groups", {"groups": item["tests"].keys()})
+        return self._output("test_groups", {"groups": list(item["tests"].keys())})
 
     def test_status(self, item):
         if "expected" not in item:
             return
         return self._output_test(item["test"], item["subtest"], item)
 
     def test_end(self, item):
         if "expected" not in item:

--- a/testing/mozbase/mozlog/mozlog/unstructured/loglistener.py
+++ b/testing/mozbase/mozlog/mozlog/unstructured/loglistener.py
@@ -1,29 +1,29 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from __future__ import absolute_import
 
-import SocketServer
+from six.moves import socketserver
+import json
 import socket
-import json
 
 
-class LogMessageServer(SocketServer.TCPServer):
+class LogMessageServer(socketserver.TCPServer):
 
     def __init__(self, server_address, logger, message_callback=None, timeout=3):
-        SocketServer.TCPServer.__init__(self, server_address, LogMessageHandler)
+        socketserver.TCPServer.__init__(self, server_address, LogMessageHandler)
         self._logger = logger
         self._message_callback = message_callback
         self.timeout = timeout
 
 
-class LogMessageHandler(SocketServer.BaseRequestHandler):
+class LogMessageHandler(socketserver.BaseRequestHandler):
     """Processes output from a connected log source, logging to an
     existing logger upon receipt of a well-formed log messsage."""
 
     def handle(self):
         """Continually listens for log messages."""
         self._partial_message = ''
         self.request.settimeout(self.server.timeout)
 

--- a/testing/mozbase/mozlog/setup.py
+++ b/testing/mozbase/mozlog/setup.py
@@ -14,27 +14,28 @@ setup(name=PACKAGE_NAME,
       description="Robust log handling specialized for logging in the Mozilla universe",
       long_description="see https://firefox-source-docs.mozilla.org/mozbase/index.html",
       author='Mozilla Automation and Testing Team',
       author_email='tools@lists.mozilla.org',
       url='https://wiki.mozilla.org/Auto-tools/Projects/Mozbase',
       license='MPL 1.1/GPL 2.0/LGPL 2.1',
       packages=find_packages(),
       zip_safe=False,
-      install_requires=["blessings>=1.3"],
+      install_requires=['blessings >= 1.3',
+                        'six >= 1.10.0'],
       tests_require=['mozfile'],
       platforms=['Any'],
       classifiers=['Development Status :: 4 - Beta',
                    'Environment :: Console',
                    'Intended Audience :: Developers',
                    'License :: OSI Approved :: Mozilla Public License 1.1 (MPL 1.1)',
                    'Operating System :: OS Independent',
-                   'Topic :: Software Development :: Libraries :: Python Modules',
                    'Programming Language :: Python :: 2.7',
-                   'Programming Language :: Python :: 2 :: Only'],
+                   'Programming Language :: Python :: 3',
+                   'Topic :: Software Development :: Libraries :: Python Modules'],
       package_data={"mozlog": ["formatters/html/main.js",
                                "formatters/html/style.css"]},
       entry_points={
           "console_scripts": [
               "structlog = mozlog.scripts:main"
           ],
           'pytest11': [
               'mozlog = mozlog.pytest_mozlog.plugin',

--- a/testing/mozbase/mozlog/tests/test_structured.py
+++ b/testing/mozbase/mozlog/tests/test_structured.py
@@ -1,21 +1,21 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import absolute_import
 
 import argparse
 import json
 import optparse
 import os
-import StringIO
 import sys
 import unittest
 import signal
 import xml.etree.ElementTree as ET
+from six import StringIO
 
 import mozunit
 
 import mozfile
 from mozlog import (
     commandline,
     reader,
     structuredlog,
@@ -629,17 +629,17 @@ class TestComponentFilter(BaseStructured
 
 
 class FormatterTest(unittest.TestCase):
 
     def setUp(self):
         self.position = 0
         self.logger = structuredlog.StructuredLogger(
             "test_%s" % type(self).__name__)
-        self.output_file = StringIO.StringIO()
+        self.output_file = StringIO()
         self.handler = handlers.StreamHandler(
             self.output_file, self.get_formatter())
         self.logger.add_handler(self.handler)
 
     def set_position(self, pos=None):
         if pos is None:
             pos = self.output_file.tell()
         self.position = pos
@@ -1098,17 +1098,17 @@ class TestBuffer(BaseStructuredTest):
         self.assert_log_equals({"action": "suite_start",
                                 "tests": {"default": []}})
 
 
 class TestReader(unittest.TestCase):
 
     def to_file_like(self, obj):
         data_str = "\n".join(json.dumps(item) for item in obj)
-        return StringIO.StringIO(data_str)
+        return StringIO(data_str)
 
     def test_read(self):
         data = [{"action": "action_0", "data": "data_0"},
                 {"action": "action_1", "data": "data_1"}]
 
         f = self.to_file_like(data)
         self.assertEquals(data, list(reader.read(f)))