Bug 1014760 - Move mozlog.structured to mozlog; Move mozlog to mozlog.unstructured, r=jgraham
authorAndrew Halberstadt <ahalberstadt@mozilla.com>
Thu, 16 Jul 2015 10:38:40 -0400
changeset 253308 5c2f87f734bee93ae29a84028705a75e46752f99
parent 253307 eb26fd0f023c45111cb73966d3e1fafb6f74ee75
child 253309 36469d73f28e41b3f8692d8987681e85efd844ad
push id29065
push userryanvm@gmail.com
push dateFri, 17 Jul 2015 14:26:32 +0000
treeherdermozilla-central@911935404233 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjgraham
bugs1014760
milestone42.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1014760 - Move mozlog.structured to mozlog; Move mozlog to mozlog.unstructured, r=jgraham Mozlog currently has two implementations. The top level package is based on the logging module and is deprecated. The newer structured logging implementation lives in mozlog.structured. This patch swaps the two, so the top level mozlog module contains the recommended implementation, while mozlog.unstructured contains the old one.
build/mobile/b2gautomation.py
build/mobile/remoteautomation.py
layout/tools/reftest/b2g_desktop.py
testing/gtest/rungtests.py
testing/luciddream/luciddream/runluciddream.py
testing/luciddream/requirements.txt
testing/mach_commands.py
testing/marionette/client/marionette/marionette_test.py
testing/marionette/client/marionette/runner/base.py
testing/marionette/client/marionette/runner/mixins/reporting.py
testing/marionette/client/marionette/runtests.py
testing/marionette/client/requirements.txt
testing/mochitest/mochitest_options.py
testing/mochitest/runtests.py
testing/mochitest/runtestsb2g.py
testing/modules/StructuredLog.jsm
testing/mozbase/docs/_static/structured_example.py
testing/mozbase/docs/loggingreporting.rst
testing/mozbase/docs/mozlog.rst
testing/mozbase/docs/mozlog_structured.rst
testing/mozbase/mozcrash/mozcrash/mozcrash.py
testing/mozbase/mozcrash/setup.py
testing/mozbase/mozcrash/tests/test.py
testing/mozbase/mozdevice/mozdevice/adb.py
testing/mozbase/mozdevice/mozdevice/devicemanager.py
testing/mozbase/mozdevice/mozdevice/devicemanagerADB.py
testing/mozbase/mozdevice/mozdevice/devicemanagerSUT.py
testing/mozbase/mozdevice/mozdevice/dmcli.py
testing/mozbase/mozdevice/setup.py
testing/mozbase/mozdevice/sut_tests/dmunit.py
testing/mozbase/mozdevice/sut_tests/runtests.py
testing/mozbase/mozdevice/tests/droidsut_launch.py
testing/mozbase/mozdevice/tests/sut_app.py
testing/mozbase/mozdevice/tests/sut_basic.py
testing/mozbase/mozdevice/tests/sut_chmod.py
testing/mozbase/mozdevice/tests/sut_copytree.py
testing/mozbase/mozdevice/tests/sut_fileMethods.py
testing/mozbase/mozdevice/tests/sut_info.py
testing/mozbase/mozdevice/tests/sut_ip.py
testing/mozbase/mozdevice/tests/sut_kill.py
testing/mozbase/mozdevice/tests/sut_list.py
testing/mozbase/mozdevice/tests/sut_logcat.py
testing/mozbase/mozdevice/tests/sut_mkdir.py
testing/mozbase/mozdevice/tests/sut_movetree.py
testing/mozbase/mozdevice/tests/sut_pull.py
testing/mozbase/mozdevice/tests/sut_push.py
testing/mozbase/mozdevice/tests/sut_remove.py
testing/mozbase/mozdevice/tests/sut_time.py
testing/mozbase/mozdevice/tests/sut_unpackfile.py
testing/mozbase/mozlog/mozlog/__init__.py
testing/mozbase/mozlog/mozlog/commandline.py
testing/mozbase/mozlog/mozlog/formatters/__init__.py
testing/mozbase/mozlog/mozlog/formatters/base.py
testing/mozbase/mozlog/mozlog/formatters/errorsummary.py
testing/mozbase/mozlog/mozlog/formatters/html/__init__.py
testing/mozbase/mozlog/mozlog/formatters/html/html.py
testing/mozbase/mozlog/mozlog/formatters/html/main.js
testing/mozbase/mozlog/mozlog/formatters/html/style.css
testing/mozbase/mozlog/mozlog/formatters/html/xmlgen.py
testing/mozbase/mozlog/mozlog/formatters/machformatter.py
testing/mozbase/mozlog/mozlog/formatters/tbplformatter.py
testing/mozbase/mozlog/mozlog/formatters/unittest.py
testing/mozbase/mozlog/mozlog/formatters/xunit.py
testing/mozbase/mozlog/mozlog/handlers/__init__.py
testing/mozbase/mozlog/mozlog/handlers/base.py
testing/mozbase/mozlog/mozlog/handlers/bufferhandler.py
testing/mozbase/mozlog/mozlog/handlers/statushandler.py
testing/mozbase/mozlog/mozlog/logger.py
testing/mozbase/mozlog/mozlog/loggingmixin.py
testing/mozbase/mozlog/mozlog/loglistener.py
testing/mozbase/mozlog/mozlog/logtypes.py
testing/mozbase/mozlog/mozlog/reader.py
testing/mozbase/mozlog/mozlog/scripts/__init__.py
testing/mozbase/mozlog/mozlog/scripts/format.py
testing/mozbase/mozlog/mozlog/scripts/logmerge.py
testing/mozbase/mozlog/mozlog/scripts/unstable.py
testing/mozbase/mozlog/mozlog/stdadapter.py
testing/mozbase/mozlog/mozlog/structured/__init__.py
testing/mozbase/mozlog/mozlog/structured/commandline.py
testing/mozbase/mozlog/mozlog/structured/formatters/__init__.py
testing/mozbase/mozlog/mozlog/structured/formatters/base.py
testing/mozbase/mozlog/mozlog/structured/formatters/errorsummary.py
testing/mozbase/mozlog/mozlog/structured/formatters/html/__init__.py
testing/mozbase/mozlog/mozlog/structured/formatters/html/html.py
testing/mozbase/mozlog/mozlog/structured/formatters/html/main.js
testing/mozbase/mozlog/mozlog/structured/formatters/html/style.css
testing/mozbase/mozlog/mozlog/structured/formatters/html/xmlgen.py
testing/mozbase/mozlog/mozlog/structured/formatters/machformatter.py
testing/mozbase/mozlog/mozlog/structured/formatters/tbplformatter.py
testing/mozbase/mozlog/mozlog/structured/formatters/unittest.py
testing/mozbase/mozlog/mozlog/structured/formatters/xunit.py
testing/mozbase/mozlog/mozlog/structured/handlers/__init__.py
testing/mozbase/mozlog/mozlog/structured/handlers/base.py
testing/mozbase/mozlog/mozlog/structured/handlers/bufferhandler.py
testing/mozbase/mozlog/mozlog/structured/handlers/statushandler.py
testing/mozbase/mozlog/mozlog/structured/logtypes.py
testing/mozbase/mozlog/mozlog/structured/reader.py
testing/mozbase/mozlog/mozlog/structured/scripts/__init__.py
testing/mozbase/mozlog/mozlog/structured/scripts/format.py
testing/mozbase/mozlog/mozlog/structured/scripts/logmerge.py
testing/mozbase/mozlog/mozlog/structured/scripts/unstable.py
testing/mozbase/mozlog/mozlog/structured/stdadapter.py
testing/mozbase/mozlog/mozlog/structured/structuredlog.py
testing/mozbase/mozlog/mozlog/structuredlog.py
testing/mozbase/mozlog/mozlog/unstructured/__init__.py
testing/mozbase/mozlog/mozlog/unstructured/logger.py
testing/mozbase/mozlog/mozlog/unstructured/loggingmixin.py
testing/mozbase/mozlog/mozlog/unstructured/loglistener.py
testing/mozbase/mozlog/setup.py
testing/mozbase/mozlog/tests/test_logger.py
testing/mozbase/mozlog/tests/test_structured.py
testing/mozbase/moznetwork/moznetwork/moznetwork.py
testing/mozbase/moznetwork/setup.py
testing/mozbase/mozprofile/mozprofile/addons.py
testing/mozbase/mozprofile/setup.py
testing/mozbase/mozprofile/tests/test_addons.py
testing/mozbase/mozrunner/mozrunner/base/runner.py
testing/mozbase/mozrunner/setup.py
testing/mozbase/mozversion/mozversion/mozversion.py
testing/mozbase/mozversion/setup.py
testing/mozbase/test.py
testing/mozharness/mozharness/mozilla/structuredlog.py
testing/remotecppunittests.py
testing/runcppunittests.py
testing/web-platform/harness/docs/usage.rst
testing/web-platform/harness/requirements.txt
testing/web-platform/harness/test/test.py
testing/web-platform/harness/wptrunner/environment.py
testing/web-platform/harness/wptrunner/metadata.py
testing/web-platform/harness/wptrunner/reduce.py
testing/web-platform/harness/wptrunner/testrunner.py
testing/web-platform/harness/wptrunner/tests/test_update.py
testing/web-platform/harness/wptrunner/vcs.py
testing/web-platform/harness/wptrunner/wptcommandline.py
testing/web-platform/harness/wptrunner/wptlogging.py
testing/web-platform/update/__init__.py
testing/xpcshell/remotexpcshelltests.py
testing/xpcshell/runtestsb2g.py
testing/xpcshell/runxpcshelltests.py
--- a/build/mobile/b2gautomation.py
+++ b/build/mobile/b2gautomation.py
@@ -12,17 +12,17 @@ import re
 import shutil
 import signal
 import tempfile
 import time
 import traceback
 import zipfile
 
 from automation import Automation
-from mozlog.structured import get_default_logger
+from mozlog import get_default_logger
 from mozprocess import ProcessHandlerMixin
 
 
 class StdOutProc(ProcessHandlerMixin):
     """Process handler for b2g which puts all output in a Queue.
     """
 
     def __init__(self, cmd, queue, **kwargs):
--- a/build/mobile/remoteautomation.py
+++ b/build/mobile/remoteautomation.py
@@ -9,17 +9,17 @@ import re
 import os
 import tempfile
 import shutil
 import subprocess
 import sys
 
 from automation import Automation
 from devicemanager import DMError, DeviceManager
-from mozlog.structured import get_default_logger
+from mozlog import get_default_logger
 import mozcrash
 
 # signatures for logcat messages that we don't care about much
 fennecLogcatFilters = [ "The character encoding of the HTML document was not declared",
                         "Use of Mutation Events is deprecated. Use MutationObserver instead.",
                         "Unexpected value from nativeGetEnabledTags: 0" ]
 
 class RemoteAutomation(Automation):
--- a/layout/tools/reftest/b2g_desktop.py
+++ b/layout/tools/reftest/b2g_desktop.py
@@ -16,17 +16,17 @@ from marionette_driver.by import By
 from marionette_driver.marionette import Marionette
 from marionette_driver.wait import Wait
 
 from mozprocess import ProcessHandler
 from mozrunner import FirefoxRunner
 import mozinfo
 import mozlog
 
-log = mozlog.getLogger('REFTEST')
+log = mozlog.unstructured.getLogger('REFTEST')
 
 class B2GDesktopReftest(RefTest):
     build_type = "desktop"
     marionette = None
 
     def __init__(self, marionette_args):
         RefTest.__init__(self)
         self.last_test = os.path.basename(__file__)
--- a/testing/gtest/rungtests.py
+++ b/testing/gtest/rungtests.py
@@ -10,17 +10,17 @@ from optparse import OptionParser
 import os
 import sys
 
 import mozcrash
 import mozinfo
 import mozlog
 import mozprocess
 
-log = mozlog.getLogger('gtest')
+log = mozlog.unstructured.getLogger('gtest')
 
 class GTests(object):
     # Time (seconds) to wait for test process to complete
     TEST_PROC_TIMEOUT = 1200
     # Time (seconds) in which process will be killed if it produces no output.
     TEST_PROC_NO_OUTPUT_TIMEOUT = 300
 
     def run_gtest(self, prog, xre_path, symbols_path=None, cwd=None):
--- a/testing/luciddream/luciddream/runluciddream.py
+++ b/testing/luciddream/luciddream/runluciddream.py
@@ -9,17 +9,17 @@ from __future__ import print_function
 import argparse
 import os
 import sys
 
 from luciddream import LucidDreamTestCase
 from marionette import Marionette
 from marionette.runner import BaseMarionetteTestRunner
 import marionette
-from mozlog import structured
+import mozlog
 
 
 class CommandLineError(Exception):
     pass
 
 
 def validate_options(options):
     if not (options.emulator_path or options.b2g_desktop_path):
@@ -55,17 +55,17 @@ def parse_args(in_args):
                         help='path to Firefox binary')
     parser.add_argument('--gaia-profile', dest='gaia_profile', action='store',
                         help='path to Gaia profile')
     parser.add_argument('--startup-timeout', dest='startup_timeout', action='store',
                         default=60,  type=int,
                         help='max time to wait for Marionette to be available after launching binary')
     parser.add_argument('manifest', metavar='MANIFEST', action='store',
                         help='path to manifest of tests to run')
-    structured.commandline.add_logging_group(parser)
+    mozlog.commandline.add_logging_group(parser)
 
     args = parser.parse_args(in_args)
     try:
         validate_options(args)
         return args
     except CommandLineError as e:
         print('Error: ', e.args[0], file=sys.stderr)
         parser.print_help()
@@ -112,17 +112,17 @@ def run(browser_path=None, b2g_desktop_p
     # it's the emulator because it feels like there's more fiddly setup around
     # that, but longer-term if we want to run tests against different
     # (non-B2G) targets this won't match up very well, so maybe it ought to
     # be the browser?
     browser = start_browser(browser_path, browser_args, kwargs['startup_timeout'])
 
     kwargs["browser"] = browser
     if not "logger" in kwargs:
-        logger = structured.commandline.setup_logging(
+        logger = mozlog.commandline.setup_logging(
             "luciddream", kwargs, {"tbpl": sys.stdout})
         kwargs["logger"] = logger
 
     if emulator_path:
         kwargs['homedir'] = emulator_path
         kwargs['emulator'] = emulator_arch
     elif b2g_desktop_path:
         # Work around bug 859952
--- a/testing/luciddream/requirements.txt
+++ b/testing/luciddream/requirements.txt
@@ -1,2 +1,2 @@
 marionette-client>=0.8.5
-mozlog
+mozlog>=3.0
--- a/testing/mach_commands.py
+++ b/testing/mach_commands.py
@@ -285,17 +285,17 @@ class MachCommands(MachCommandBase):
         description='Run cpp unit tests (C++ tests).')
     @CommandArgument('test_files', nargs='*', metavar='N',
         help='Test to run. Can be specified as one or more files or ' \
             'directories, or omitted. If omitted, the entire test suite is ' \
             'executed.')
 
     def run_cppunit_test(self, **params):
         import mozinfo
-        from mozlog.structured import commandline
+        from mozlog import commandline
         import runcppunittests as cppunittests
 
         log = commandline.setup_logging("cppunittest",
                                         {},
                                         {"tbpl": sys.stdout})
 
         if len(params['test_files']) == 0:
             testdir = os.path.join(self.distdir, 'cppunittests')
--- a/testing/marionette/client/marionette/marionette_test.py
+++ b/testing/marionette/client/marionette/marionette_test.py
@@ -19,19 +19,19 @@ from marionette_driver.errors import (
         MarionetteException, TimeoutException,
         JavascriptException, NoSuchElementException, NoSuchWindowException,
         StaleElementException, ScriptTimeoutException, ElementNotVisibleException,
         NoSuchFrameException, InvalidElementStateException, NoAlertPresentException,
         InvalidCookieDomainException, UnableToSetCookieException, InvalidSelectorException,
         MoveTargetOutOfBoundsException, FrameSendNotInitializedError, FrameSendFailureError
         )
 from marionette_driver.marionette import Marionette
-from mozlog.structured.structuredlog import get_default_logger
 from marionette_driver.wait import Wait
 from marionette_driver.expected import element_present, element_not_present
+from mozlog import get_default_logger
 
 
 class SkipTest(Exception):
     """
     Raise this exception in a test to skip it.
 
     Usually you can use TestResult.skip() or one of the skipping decorators
     instead of raising this directly.
@@ -371,17 +371,17 @@ class CommonTestCase(unittest.TestCase):
         else:
             return '%s.py %s.%s' % (self.__class__.__module__,
                                     self.__class__.__name__,
                                     self._testMethodName)
 
     def id(self):
         # TBPL starring requires that the "test name" field of a failure message
         # not differ over time. The test name to be used is passed to
-        # mozlog.structured via the test id, so this is overriden to maintain
+        # mozlog via the test id, so this is overriden to maintain
         # consistency.
         return self.test_name
 
     def set_up_test_page(self, emulator, url="test.html", permissions=None):
         emulator.set_context("content")
         url = emulator.absolute_url(url)
         emulator.navigate(url)
 
--- a/testing/marionette/client/marionette/runner/base.py
+++ b/testing/marionette/client/marionette/runner/base.py
@@ -16,17 +16,17 @@ import traceback
 import unittest
 import warnings
 import xml.dom.minidom as dom
 
 from manifestparser import TestManifest
 from manifestparser.filters import tags
 from marionette_driver.marionette import Marionette
 from mixins.b2g import B2GTestResultMixin, get_b2g_pid, get_dm
-from mozlog.structured.structuredlog import get_default_logger
+from mozlog import get_default_logger
 from moztest.adapters.unit import StructuredTestRunner, StructuredTestResult
 from moztest.results import TestResultCollection, TestResult, relevant_line
 import mozversion
 
 import httpd
 
 
 here = os.path.abspath(os.path.dirname(__file__))
--- a/testing/marionette/client/marionette/runner/mixins/reporting.py
+++ b/testing/marionette/client/marionette/runner/mixins/reporting.py
@@ -6,17 +6,17 @@ import base64
 import cgi
 import datetime
 import json
 import os
 import pkg_resources
 import sys
 import time
 
-from mozlog.structured.structuredlog import get_default_logger
+from mozlog import get_default_logger
 import mozversion
 from xmlgen import html
 from xmlgen import raw
 
 
 class HTMLReportingTestRunnerMixin(object):
 
     def __init__(self, name=None, version=None, html_output=None, **kwargs):
--- a/testing/marionette/client/marionette/runtests.py
+++ b/testing/marionette/client/marionette/runtests.py
@@ -1,22 +1,22 @@
 # 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/.
 
 import sys
 
 from marionette import __version__
 from marionette.marionette_test import MarionetteTestCase, MarionetteJSTestCase
-from mozlog import structured
 from marionette.runner import (
     BaseMarionetteTestRunner,
     BaseMarionetteOptions,
     BrowserMobProxyOptionsMixin
-    )
+)
+import mozlog
 
 
 class MarionetteTestRunner(BaseMarionetteTestRunner):
     def __init__(self, **kwargs):
         BaseMarionetteTestRunner.__init__(self, **kwargs)
         self.test_handlers = [MarionetteTestCase, MarionetteJSTestCase]
 
 
@@ -33,21 +33,21 @@ def startTestRunner(runner_class, option
 
     runner = runner_class(**vars(options))
     runner.run_tests(tests)
     return runner
 
 def cli(runner_class=MarionetteTestRunner, parser_class=MarionetteOptions):
     parser = parser_class(usage='%prog [options] test_file_or_dir <test_file_or_dir> ...',
                           version='%prog ' + __version__)
-    structured.commandline.add_logging_group(parser)
+    mozlog.commandline.add_logging_group(parser)
     options, tests = parser.parse_args()
     parser.verify_usage(options, tests)
 
-    logger = structured.commandline.setup_logging(
+    logger = mozlog.commandline.setup_logging(
         options.logger_name, options, {"tbpl": sys.stdout})
 
     options.logger = logger
 
     runner = startTestRunner(runner_class, options, tests)
     if runner.failed > 0:
         sys.exit(10)
 
--- a/testing/marionette/client/requirements.txt
+++ b/testing/marionette/client/requirements.txt
@@ -1,14 +1,14 @@
 marionette-driver >= 0.8
 browsermob-proxy >= 0.6.0
 manifestparser >= 1.1
 mozhttpd >= 0.7
 mozinfo >= 0.8
 mozprocess >= 0.9
 mozrunner >= 6.2
 mozdevice >= 0.44
-mozlog >= 2.7
+mozlog >= 3.0
 moznetwork >= 0.21
 mozcrash >= 0.5
 mozprofile >= 0.7
 moztest >= 0.7
 mozversion >= 1.1
--- a/testing/mochitest/mochitest_options.py
+++ b/testing/mochitest/mochitest_options.py
@@ -4,19 +4,19 @@
 
 from abc import ABCMeta, abstractmethod, abstractproperty
 from argparse import ArgumentParser, SUPPRESS
 from urlparse import urlparse
 import os
 import tempfile
 
 from droid import DroidADB, DroidSUT
-from mozlog import structured
 from mozprofile import DEFAULT_PORTS
 import mozinfo
+import mozlog
 import moznetwork
 
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 try:
     from mozbuild.base import (
         MozbuildObject,
@@ -1183,17 +1183,17 @@ class MochitestArgumentParser(ArgumentPa
                 if 'suppress' in kwargs:
                     if kwargs['suppress']:
                         kwargs['help'] = SUPPRESS
                     del kwargs['suppress']
 
                 group.add_argument(*cli, **kwargs)
 
         self.set_defaults(**defaults)
-        structured.commandline.add_logging_group(self)
+        mozlog.commandline.add_logging_group(self)
 
     @property
     def containers(self):
         if self._containers:
             return self._containers
 
         containers = container_map[self.app]
         self._containers = [c() for c in containers]
--- a/testing/mochitest/runtests.py
+++ b/testing/mochitest/runtests.py
@@ -50,18 +50,18 @@ from manifestparser.filters import (
     subsuite,
     tags,
 )
 from leaks import ShutdownLeaks, LSANLeaks
 from mochitest_options import MochitestArgumentParser, build_obj
 from mozprofile import Profile, Preferences
 from mozprofile.permissions import ServerLocations
 from urllib import quote_plus as encodeURIComponent
-from mozlog.structured.formatters import TbplFormatter
-from mozlog.structured import commandline
+from mozlog.formatters import TbplFormatter
+from mozlog import commandline
 from mozrunner.utils import test_environment
 import mozleak
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 
 ###########################
 # Option for NSPR logging #
--- a/testing/mochitest/runtestsb2g.py
+++ b/testing/mochitest/runtestsb2g.py
@@ -14,17 +14,16 @@ import traceback
 here = os.path.abspath(os.path.dirname(__file__))
 sys.path.insert(0, here)
 
 from runtests import Mochitest
 from runtests import MochitestUtilsMixin
 from mochitest_options import MochitestArgumentParser
 from marionette import Marionette
 from mozprofile import Profile, Preferences
-from mozlog import structured
 import mozinfo
 import mozleak
 
 
 class B2GMochitest(MochitestUtilsMixin):
     marionette = None
 
     def __init__(self, marionette_args,
--- a/testing/modules/StructuredLog.jsm
+++ b/testing/modules/StructuredLog.jsm
@@ -5,17 +5,17 @@
 "use strict";
 
 this.EXPORTED_SYMBOLS = [
   "StructuredLogger"
 ];
 
 /**
  * TestLogger: Logger class generating messages compliant with the
- * structured logging protocol for tests exposed by the mozlog.structured
+ * structured logging protocol for tests exposed by mozlog
  *
  * @param name
  *        The name of the logger to instantiate.
  * @param dumpFun
  *        An underlying function to be used to log raw messages. This function
  *        will receive the complete serialized json string to log.
  * @param mutators
  *        An array of functions used to add global context to log messages.
@@ -25,18 +25,17 @@ this.EXPORTED_SYMBOLS = [
 this.StructuredLogger = function (name, dumpFun=dump, mutators=[]) {
   this.name = name;
   this._dumpFun = dumpFun;
   this._mutatorFuns = mutators;
   this._runningTests = new Set();
 }
 
 /**
- * Log functions producing messages in the format specified by
- * mozlog.structured
+ * Log functions producing messages in the format specified by mozlog
  */
 StructuredLogger.prototype.testStart = function (test) {
   this._runningTests.add(test);
   let data = {test: test};
   this._logData("test_start", data);
 }
 
 StructuredLogger.prototype.testStatus = function (test, subtest, status, expected="PASS",
--- a/testing/mozbase/docs/_static/structured_example.py
+++ b/testing/mozbase/docs/_static/structured_example.py
@@ -1,14 +1,14 @@
 import argparse
 import sys
 import traceback
 import types
 
-from mozlog.structured import commandline, get_default_logger
+from mozlog import commandline, get_default_logger
 
 class TestAssertion(Exception):
     pass
 
 def assert_equals(a, b):
     if a != b:
         raise TestAssertion("%r not equal to %r" % (a, b))
 
--- a/testing/mozbase/docs/loggingreporting.rst
+++ b/testing/mozbase/docs/loggingreporting.rst
@@ -3,9 +3,9 @@ Logging and reporting
 
 Ideally output between different types of testing system should be as
 uniform as possible, as well as making it easy to make things more or
 less verbose. We created some libraries to make doing this easy.
 
 .. toctree::
    :maxdepth: 2
 
-   mozlog_structured
+   mozlog
rename from testing/mozbase/docs/mozlog_structured.rst
rename to testing/mozbase/docs/mozlog.rst
--- a/testing/mozbase/docs/mozlog_structured.rst
+++ b/testing/mozbase/docs/mozlog.rst
@@ -1,18 +1,18 @@
-:mod:`mozlog.structured` --- Structured logging for test output
+:mod:`mozlog` --- Structured logging for test output
 ===============================================================
 
-:py:mod:`mozlog.structured` is a library designed for logging the
+:py:mod:`mozlog` is a library designed for logging the
 execution and results of test harnesses. The internal data model is a
 stream of JSON-compatible objects, with one object per log entry. The
 default output format is line-based, with one JSON object serialized
 per line.
 
-:py:mod:`mozlog.structured` is *not* based on the stdlib logging
+:py:mod:`mozlog` is *not* based on the stdlib logging
 module, although it shares several concepts with it.
 
 One notable difference between this module and the standard logging
 module is the way that loggers are created. The structured logging
 module does not require that loggers with a specific name are
 singleton objects accessed through a factory function. Instead the
 ``StructuredLogger`` constructor may be used directly. However all
 loggers with the same name share the same internal state (the "Borg"
@@ -194,17 +194,17 @@ without error. If no errors were detecte
 status ``OK``. Otherwise the test may get the status ``ERROR`` (for
 e.g. uncaught JS exceptions), ``TIMEOUT`` (if no results were reported
 in the allowed time) or ``CRASH`` (if the test caused the process
 under test to crash).
 
 StructuredLogger Objects
 ------------------------
 
-.. automodule:: mozlog.structured.structuredlog
+.. automodule:: mozlog.structuredlog
   :members: set_default_logger, get_default_logger
 
 .. autoclass:: StructuredLogger
    :members: add_handler, remove_handler, handlers, suite_start,
              suite_end, test_start, test_status, test_end,
              process_output, critical, error, warning, info, debug
 
 .. autoclass:: StructuredLogFileLike
@@ -214,17 +214,17 @@ Handlers
 --------
 
 A handler is a callable that is called for each log message produced
 and is responsible for handling the processing of that
 message. The typical example of this is a ``StreamHandler`` which takes
 a log message, invokes a formatter which converts the log to a string,
 and writes it to a file.
 
-.. automodule:: mozlog.structured.handlers
+.. automodule:: mozlog.handlers
 
 .. autoclass:: BaseHandler
   :members:
 
 .. autoclass:: StreamHandler
   :members:
 
 .. autoclass:: LogLevelFilter
@@ -243,102 +243,102 @@ exclude certain items and create interna
 that, for example, a single string might be returned for a
 ``test_end`` message indicating the overall result of the test,
 including data provided in the ``test_status`` messages.
 
 Formatter modules are written so that they can take raw input on stdin
 and write formatted output on stdout. This allows the formatters to be
 invoked as part of a command line for post-processing raw log files.
 
-.. automodule:: mozlog.structured.formatters.base
+.. automodule:: mozlog.formatters.base
 
 .. autoclass:: BaseFormatter
   :members:
 
-.. automodule:: mozlog.structured.formatters.unittest
+.. automodule:: mozlog.formatters.unittest
 
 .. autoclass:: UnittestFormatter
   :members:
 
-.. automodule:: mozlog.structured.formatters.xunit
+.. automodule:: mozlog.formatters.xunit
 
 .. autoclass:: XUnitFormatter
   :members:
 
-.. automodule:: mozlog.structured.formatters.html
+.. automodule:: mozlog.formatters.html
 
 .. autoclass:: HTMLFormatter
   :members:
 
-.. automodule:: mozlog.structured.formatters.machformatter
+.. automodule:: mozlog.formatters.machformatter
 
 .. autoclass:: MachFormatter
   :members:
 
-.. automodule:: mozlog.structured.formatters.tbplformatter
+.. automodule:: mozlog.formatters.tbplformatter
 
 .. autoclass:: TbplFormatter
   :members:
 
 Processing Log Files
 --------------------
 
-The ``mozlog.structured.reader`` module provides utilities for working
+The ``mozlog.reader`` module provides utilities for working
 with structured log files.
 
-.. automodule:: mozlog.structured.reader
+.. automodule:: mozlog.reader
   :members:
 
 Integration with argparse
 -------------------------
 
-The `mozlog.structured.commandline` module provides integration with
-the `argparse` module to provide uniform logging-related command line
-arguments to programs using `mozlog.structured`. Each known formatter
-gets a command line argument of the form ``--log-{name}``, which takes
-the name of a file to log to with that format, or ``-`` to indicate stdout.
+The `mozlog.commandline` module provides integration with the `argparse`
+module to provide uniform logging-related command line arguments to programs
+using `mozlog`. Each known formatter gets a command line argument of the form
+``--log-{name}``, which takes the name of a file to log to with that format,
+or ``-`` to indicate stdout.
 
-.. automodule:: mozlog.structured.commandline
+.. automodule:: mozlog.commandline
   :members:
 
 Simple Examples
 ---------------
 
 Log to stdout::
 
-    from mozlog.structured import structuredlog
-    from mozlog.structured import handlers, formatters
+    from mozlog import structuredlog
+    from mozlog import handlers, formatters
     logger = structuredlog.StructuredLogger("my-test-suite")
     logger.add_handler(handlers.StreamHandler(sys.stdout,
                                               formatters.JSONFormatter()))
     logger.suite_start(["test-id-1"])
     logger.test_start("test-id-1")
     logger.info("This is a message with action='LOG' and level='INFO'")
     logger.test_status("test-id-1", "subtest-1", "PASS")
     logger.test_end("test-id-1", "OK")
     logger.suite_end()
 
 
 Populate an ``argparse.ArgumentParser`` with logging options, and
 create a logger based on the value of those options, defaulting to
 JSON output on stdout if nothing else is supplied::
 
    import argparse
-   from mozlog.structured import commandline
+   from mozlog import commandline
 
    parser = argparse.ArgumentParser()
    # Here one would populate the parser with other options
    commandline.add_logging_group(parser)
 
    args = parser.parse_args()
    logger = commandline.setup_logging("testsuite-name", args, {"raw": sys.stdout})
 
 Count the number of tests that timed out in a testsuite::
 
-   from mozlog.structured import reader
+   from mozlog import reader
 
    count = 0
 
    def handle_test_end(data):
        global count
        if data["status"] == "TIMEOUT":
            count += 1
 
@@ -368,17 +368,17 @@ function. This is responsible for parsin
 arguments, and initiating the test run. Although the test harness
 itself does not provide any command line arguments, the
 :py:class:`ArgumentParser` object is populated by
 :py:meth:`commandline.add_logging_group`, which provides a generic
 set of structured logging arguments appropriate to all tools producing
 structured logging.
 
 The values of these command line arguments are used to create a
-:py:class:`mozlog.structured.StructuredLogger` object populated with the
+:py:class:`mozlog.StructuredLogger` object populated with the
 specified handlers and formatters in
 :py:func:`commandline.setup_logging`. The third argument to this
 function is the default arguments to use. In this case the default
 is to output raw (i.e. JSON-formatted) logs to stdout.
 
 The main test harness is provided by the :py:class:`TestRunner`
 class. This class is responsible for scheduling all the tests and
 logging all the results. It is passed the :py:obj:`logger` object
--- a/testing/mozbase/mozcrash/mozcrash/mozcrash.py
+++ b/testing/mozbase/mozcrash/mozcrash/mozcrash.py
@@ -18,33 +18,32 @@ import sys
 import tempfile
 import urllib2
 import zipfile
 from collections import namedtuple
 
 import mozfile
 import mozinfo
 import mozlog
-from mozlog.structured import structuredlog
 
 
 StackInfo = namedtuple("StackInfo",
                        ["minidump_path",
                         "signature",
                         "stackwalk_stdout",
                         "stackwalk_stderr",
                         "stackwalk_retcode",
                         "stackwalk_errors",
                         "extra"])
 
 
 def get_logger():
-    structured_logger = structuredlog.get_default_logger("mozcrash")
+    structured_logger = mozlog.get_default_logger("mozcrash")
     if structured_logger is None:
-        return mozlog.getLogger('mozcrash')
+        return mozlog.unstructured.getLogger('mozcrash')
     return structured_logger
 
 
 def check_for_crashes(dump_directory,
                       symbols_path,
                       stackwalk_binary=None,
                       dump_save_path=None,
                       test_name=None,
--- a/testing/mozbase/mozcrash/setup.py
+++ b/testing/mozbase/mozcrash/setup.py
@@ -4,17 +4,17 @@
 
 from setuptools import setup
 
 PACKAGE_NAME = 'mozcrash'
 PACKAGE_VERSION = '0.14'
 
 # dependencies
 deps = ['mozfile >= 1.0',
-        'mozlog']
+        'mozlog >= 3.0']
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
       description="Library for printing stack traces from minidumps left behind by crashed processes",
       long_description="see http://mozbase.readthedocs.org/",
       classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
       keywords='mozilla',
       author='Mozilla Automation and Tools team',
--- a/testing/mozbase/mozcrash/tests/test.py
+++ b/testing/mozbase/mozcrash/tests/test.py
@@ -1,16 +1,18 @@
 #!/usr/bin/env python
 #
 # 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/.
 
 import os, unittest, subprocess, tempfile, shutil, urlparse, zipfile, StringIO
-import mozcrash, mozlog, mozhttpd
+import mozcrash
+import mozhttpd
+import mozlog.unstructured as mozlog
 
 # Make logs go away
 log = mozlog.getLogger("mozcrash", handler=mozlog.FileHandler(os.devnull))
 
 def popen_factory(stdouts):
     """
     Generate a class that can mock subprocess.Popen. |stdouts| is an iterable that
     should return an iterable for the stdout of each process in turn.
--- a/testing/mozbase/mozdevice/mozdevice/adb.py
+++ b/testing/mozbase/mozdevice/mozdevice/adb.py
@@ -158,18 +158,18 @@ class ADBCommand(object):
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE).communicate()
         except Exception, exc:
             raise ADBError('%s: %s is not executable.' % (exc, adb))
 
     def _get_logger(self, logger_name):
         logger = None
         try:
-            from mozlog import structured
-            logger = structured.get_default_logger(logger_name)
+            import mozlog
+            logger = mozlog.get_default_logger(logger_name)
         except ImportError:
             pass
 
         if logger is None:
             import logging
             logger = logging.getLogger(logger_name)
         return logger
 
--- a/testing/mozbase/mozdevice/mozdevice/devicemanager.py
+++ b/testing/mozbase/mozdevice/mozdevice/devicemanager.py
@@ -1,14 +1,15 @@
 # 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/.
 
 import hashlib
 import mozlog
+import logging
 import os
 import posixpath
 import re
 import struct
 import StringIO
 import zlib
 
 from functools import wraps
@@ -45,19 +46,19 @@ class DeviceManager(object):
     """
 
     _logcatNeedsRoot = True
     default_timeout = 300
     short_timeout = 30
 
     def __init__(self, logLevel=None, deviceRoot=None):
         try:
-            self._logger = mozlog.structured.structuredlog.get_default_logger(component="mozdevice")
+            self._logger = mozlog.get_default_logger(component="mozdevice")
             if not self._logger: # no global structured logger, fall back to reg logging
-                self._logger = mozlog.getLogger("mozdevice")
+                self._logger = mozlog.unstructured.getLogger("mozdevice")
                 if logLevel is not None:
                     self._logger.setLevel(logLevel)
         except AttributeError:
             # Structured logging doesn't work on Python 2.6
             self._logger = None
         self._logLevel = logLevel
         self._remoteIsWin = None
         self._isDeviceRootSetup = False
@@ -83,26 +84,26 @@ class DeviceManager(object):
     @logLevel.setter
     def logLevel_setter(self, newLogLevel):
         self._logLevel = newLogLevel
         self._logger.setLevel(self._logLevel)
 
     @property
     def debug(self):
         self._logger.warning("dm.debug is deprecated. Use logLevel.")
-        levels = {mozlog.DEBUG: 5, mozlog.INFO: 3, mozlog.WARNING: 2,
-                  mozlog.ERROR: 1, mozlog.CRITICAL: 0}
+        levels = {logging.DEBUG: 5, logging.INFO: 3, logging.WARNING: 2,
+                  logging.ERROR: 1, logging.CRITICAL: 0}
         return levels[self.logLevel]
 
     @debug.setter
     def debug_setter(self, newDebug):
         self._logger.warning("dm.debug is deprecated. Use logLevel.")
         newDebug = 5 if newDebug > 5 else newDebug # truncate >=5 to 5
-        levels = {5: mozlog.DEBUG, 3: mozlog.INFO, 2: mozlog.WARNING,
-                  1: mozlog.ERROR, 0: mozlog.CRITICAL}
+        levels = {5: logging.DEBUG, 3: logging.INFO, 2: logging.WARNING,
+                  1: logging.ERROR, 0: logging.CRITICAL}
         self.logLevel = levels[newDebug]
 
     @abstractmethod
     def getInfo(self, directive=None):
         """
         Returns a dictionary of information strings about the device.
 
         :param directive: information you want to get. Options are:
--- a/testing/mozbase/mozdevice/mozdevice/devicemanagerADB.py
+++ b/testing/mozbase/mozdevice/mozdevice/devicemanagerADB.py
@@ -1,23 +1,23 @@
 # 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/.
 
+import logging
 import re
 import os
 import shutil
 import tempfile
 import time
 import traceback
 
 from devicemanager import DeviceManager, DMError
 from mozprocess import ProcessHandler
 import mozfile
-import mozlog
 
 
 class DeviceManagerADB(DeviceManager):
     """
     Implementation of DeviceManager interface that uses the Android "adb"
     utility to communicate with the device. Normally used to communicate
     with a device that is directly connected with the host machine over a USB
     port.
@@ -29,17 +29,17 @@ class DeviceManagerADB(DeviceManager):
     _logcatNeedsRoot = False
     _pollingInterval = 0.01
     _packageName = None
     _tempDir = None
     connected = False
 
     def __init__(self, host=None, port=5555, retryLimit=5, packageName='fennec',
                  adbPath='adb', deviceSerial=None, deviceRoot=None,
-                 logLevel=mozlog.ERROR, autoconnect=True, runAdbAsRoot=False,
+                 logLevel=logging.ERROR, autoconnect=True, runAdbAsRoot=False,
                  serverHost=None, serverPort=None, **kwargs):
         DeviceManager.__init__(self, logLevel=logLevel,
                                deviceRoot=deviceRoot)
         self.host = host
         self.port = port
         self.retryLimit = retryLimit
 
         self._serverHost = serverHost
--- a/testing/mozbase/mozdevice/mozdevice/devicemanagerSUT.py
+++ b/testing/mozbase/mozdevice/mozdevice/devicemanagerSUT.py
@@ -1,14 +1,14 @@
 # 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/.
 
 import datetime
-import mozlog
+import logging
 import moznetwork
 import select
 import socket
 import time
 import os
 import re
 import posixpath
 import subprocess
@@ -29,20 +29,20 @@ class DeviceManagerSUT(DeviceManager):
     _base_prompt_re = '\$\>'
     _prompt_sep = '\x00'
     _prompt_regex = '.*(' + _base_prompt_re + _prompt_sep + ')'
     _agentErrorRE = re.compile('^##AGENT-WARNING##\ ?(.*)')
 
     reboot_timeout = 600
     reboot_settling_time = 60
 
-    def __init__(self, host, port = 20701, retryLimit = 5,
-            deviceRoot = None, logLevel = mozlog.ERROR, **kwargs):
-        DeviceManager.__init__(self, logLevel = logLevel,
-                               deviceRoot = deviceRoot)
+    def __init__(self, host, port=20701, retryLimit=5, deviceRoot=None,
+                 logLevel=logging.ERROR, **kwargs):
+        DeviceManager.__init__(self, logLevel=logLevel,
+                               deviceRoot=deviceRoot)
         self.host = host
         self.port = port
         self.retryLimit = retryLimit
         self._sock = None
         self._everConnected = False
 
         # Get version
         verstring = self._runCmds([{ 'cmd': 'ver' }])
--- a/testing/mozbase/mozdevice/mozdevice/dmcli.py
+++ b/testing/mozbase/mozdevice/mozdevice/dmcli.py
@@ -2,16 +2,17 @@
 # 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/.
 
 """
 Command-line client to control a device
 """
 
 import errno
+import logging
 import os
 import posixpath
 import StringIO
 import sys
 import mozdevice
 import mozlog
 import argparse
 
@@ -129,22 +130,22 @@ class DMCli(object):
                                      'args': [ { 'name': 'interface', 'nargs': '*' } ],
                                      'help': 'get the ip address of the device'
                                    }
                           }
 
         self.parser = argparse.ArgumentParser()
         self.add_options(self.parser)
         self.add_commands(self.parser)
-        mozlog.structured.commandline.add_logging_group(self.parser)
+        mozlog.commandline.add_logging_group(self.parser)
 
     def run(self, args=sys.argv[1:]):
         args = self.parser.parse_args()
 
-        mozlog.structured.commandline.setup_logging(
+        mozlog.commandline.setup_logging(
             'mozdevice', args, {'mach': sys.stdout})
 
         if args.dmtype == "sut" and not args.host and not args.hwid:
             self.parser.error("Must specify device ip in TEST_DEVICE or "
                               "with --host option with SUT")
 
         self.dm = self.getDevice(dmtype=args.dmtype, hwid=args.hwid,
                                  host=args.host, port=args.port,
@@ -197,19 +198,19 @@ class DMCli(object):
                     subparser.add_argument(arg['name'], **kwargs)
             subparser.set_defaults(func=commandprops['function'])
 
     def getDevice(self, dmtype="adb", hwid=None, host=None, port=None,
                   packagename=None, verbose=False):
         '''
         Returns a device with the specified parameters
         '''
-        logLevel = mozlog.ERROR
+        logLevel = logging.ERROR
         if verbose:
-            logLevel = mozlog.DEBUG
+            logLevel = logging.DEBUG
 
         if hwid:
             return mozdevice.DroidConnectByHWID(hwid, logLevel=logLevel)
 
         if dmtype == "adb":
             if host and not port:
                 port = 5555
             return mozdevice.DroidADB(packageName=packagename,
--- a/testing/mozbase/mozdevice/setup.py
+++ b/testing/mozbase/mozdevice/setup.py
@@ -3,17 +3,17 @@
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from setuptools import setup
 
 PACKAGE_NAME = 'mozdevice'
 PACKAGE_VERSION = '0.45'
 
 deps = ['mozfile >= 1.0',
-        'mozlog >= 2.1',
+        'mozlog >= 3.0',
         'moznetwork >= 0.24',
         'mozprocess >= 0.19',
        ]
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
       description="Mozilla-authored device management",
       long_description="see http://mozbase.readthedocs.org/",
--- a/testing/mozbase/mozdevice/sut_tests/dmunit.py
+++ b/testing/mozbase/mozdevice/sut_tests/dmunit.py
@@ -1,24 +1,23 @@
 # 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/.
 
+import logging
 import types
 import unittest
 
-import mozlog
-
 from mozdevice import devicemanager
 from mozdevice import devicemanagerSUT
 
 ip = ''
 port = 0
 heartbeat_port = 0
-log_level = mozlog.ERROR
+log_level = logging.ERROR
 
 class DeviceManagerTestCase(unittest.TestCase):
     """DeviceManager tests should subclass this.
     """
 
     """Set to False in your derived class if this test
     should not be run on the Python agent.
     """
--- a/testing/mozbase/mozdevice/sut_tests/runtests.py
+++ b/testing/mozbase/mozdevice/sut_tests/runtests.py
@@ -1,30 +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 optparse import OptionParser
+import logging
 import os
 import re
 import sys
 import unittest
 
-import mozlog
-
 import dmunit
 import genfiles
 
 
 def main(ip, port, heartbeat_port, scripts, directory, isTestDevice, verbose):
     dmunit.ip = ip
     dmunit.port = port
     dmunit.heartbeat_port = heartbeat_port
     if verbose:
-        dmunit.log_level = mozlog.DEBUG
+        dmunit.log_level = logging.DEBUG
 
     suite = unittest.TestSuite()
 
     genfiles.gen_test_files()
 
     if scripts:
         # Ensure the user didn't include the .py on the name of the test file
         # (and get rid of it if they did)
--- a/testing/mozbase/mozdevice/tests/droidsut_launch.py
+++ b/testing/mozbase/mozdevice/tests/droidsut_launch.py
@@ -1,35 +1,35 @@
 from sut import MockAgent
 import mozdevice
-import mozlog
+import logging
 import unittest
 
 class LaunchTest(unittest.TestCase):
 
     def test_nouserserial(self):
         a = MockAgent(self, commands = [("ps",
                                          "10029	549	com.android.launcher\n"
                                          "10066	1198	com.twitter.android"),
                                         ("info sutuserinfo", ""),
                                         ("exec am start -W -n "
                                          "org.mozilla.fennec/.App -a "
                                          "android.intent.action.VIEW",
                                          "OK\nreturn code [0]")])
-        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
         d.launchFennec("org.mozilla.fennec")
         a.wait()
 
     def test_userserial(self):
         a = MockAgent(self, commands = [("ps",
                                          "10029	549	com.android.launcher\n"
                                          "10066	1198	com.twitter.android"),
                                         ("info sutuserinfo", "User Serial:0"),
                                         ("exec am start --user 0 -W -n "
                                          "org.mozilla.fennec/.App -a "
                                          "android.intent.action.VIEW",
                                          "OK\nreturn code [0]")])
-        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
         d.launchFennec("org.mozilla.fennec")
         a.wait()
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_app.py
+++ b/testing/mozbase/mozdevice/tests/sut_app.py
@@ -1,20 +1,20 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestApp(unittest.TestCase):
 
     def test_getAppRoot(self):
         command = [("getapproot org.mozilla.firefox",
                     "/data/data/org.mozilla.firefox")]
 
         m = MockAgent(self, commands=command)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
 
         self.assertEqual(command[0][1], d.getAppRoot('org.mozilla.firefox'))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_basic.py
+++ b/testing/mozbase/mozdevice/tests/sut_basic.py
@@ -1,51 +1,51 @@
 from sut import MockAgent
 import mozdevice
-import mozlog
+import logging
 import unittest
 
 class BasicTest(unittest.TestCase):
 
     def test_init(self):
         """Tests DeviceManager initialization."""
         a = MockAgent(self)
 
-        mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=mozlog.DEBUG)
+        mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
         # all testing done in device's constructor
         a.wait()
 
     def test_init_err(self):
         """Tests error handling during initialization."""
         a = MockAgent(self, start_commands=[("ver", "##AGENT-WARNING## No version")])
         self.assertRaises(mozdevice.DMError,
                           lambda: mozdevice.DroidSUT("127.0.0.1",
                                                      port=a.port,
-                                                     logLevel=mozlog.DEBUG))
+                                                     logLevel=logging.DEBUG))
         a.wait()
 
     def test_timeout_normal(self):
         """Tests DeviceManager timeout, normal case."""
         a = MockAgent(self, commands = [("isdir /mnt/sdcard/tests", "TRUE"),
                                         ("cd /mnt/sdcard/tests", ""),
                                         ("ls", "test.txt"),
                                         ("rm /mnt/sdcard/tests/test.txt",
                                          "Removed the file")])
-        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
         ret = d.removeFile('/mnt/sdcard/tests/test.txt')
         self.assertEqual(ret, None) # if we didn't throw an exception, we're ok
         a.wait()
 
     def test_timeout_timeout(self):
         """Tests DeviceManager timeout, timeout case."""
         a = MockAgent(self, commands = [("isdir /mnt/sdcard/tests", "TRUE"),
                                         ("cd /mnt/sdcard/tests", ""),
                                         ("ls", "test.txt"),
                                         ("rm /mnt/sdcard/tests/test.txt", 0)])
-        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=a.port, logLevel=logging.DEBUG)
         d.default_timeout = 1
         exceptionThrown = False
         try:
             d.removeFile('/mnt/sdcard/tests/test.txt')
         except mozdevice.DMError:
             exceptionThrown = True
         self.assertEqual(exceptionThrown, True)
         a.should_stop = True
--- a/testing/mozbase/mozdevice/tests/sut_chmod.py
+++ b/testing/mozbase/mozdevice/tests/sut_chmod.py
@@ -1,21 +1,21 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestChmod(unittest.TestCase):
 
     def test_chmod(self):
 
         command = [('chmod /mnt/sdcard/test', 'Changing permissions for /storage/emulated/legacy/Test\n'
                                               '        <empty>\n'
                                               'chmod /storage/emulated/legacy/Test ok\n')]
         m = MockAgent(self, commands=command)
-        d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=logging.DEBUG)
 
         self.assertEqual(None, d.chmodDir('/mnt/sdcard/test'))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_copytree.py
+++ b/testing/mozbase/mozdevice/tests/sut_copytree.py
@@ -1,44 +1,44 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
 # 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/.
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 class CopyTreeTest(unittest.TestCase):
     def test_copyFile(self):
         commands = [('dd if=/mnt/sdcard/tests/test.txt of=/mnt/sdcard/tests/test2.txt', ''),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'test.txt\ntest2.txt')]
 
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
 
         self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/test.txt',
                 '/mnt/sdcard/tests/test2.txt'))
         expected = (commands[3][1].strip()).split('\n')
         self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
 
     def test_copyDir(self):
         commands = [('dd if=/mnt/sdcard/tests/foo of=/mnt/sdcard/tests/bar', ''),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'foo\nbar')]
 
         m = MockAgent(self, commands=commands)
         d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
-                logLevel=mozlog.DEBUG)
+                logLevel=logging.DEBUG)
 
         self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/foo',
                 '/mnt/sdcard/tests/bar'))
         expected = (commands[3][1].strip()).split('\n')
         self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
 
     def test_copyNonEmptyDir(self):
         commands = [('isdir /mnt/sdcard/tests/foo/bar', 'TRUE'),
@@ -47,17 +47,17 @@ class CopyTreeTest(unittest.TestCase):
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'foo\nfoo2'),
                     ('isdir /mnt/sdcard/tests/foo2', 'TRUE'),
                     ('cd /mnt/sdcard/tests/foo2', ''),
                     ('ls', 'bar')]
 
         m = MockAgent(self, commands=commands)
         d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
-                logLevel=mozlog.DEBUG)
+                logLevel=logging.DEBUG)
 
         self.assertTrue(d.dirExists('/mnt/sdcard/tests/foo/bar'))
         self.assertEqual(None, d.copyTree('/mnt/sdcard/tests/foo',
                 '/mnt/sdcard/tests/foo2'))
         expected = (commands[4][1].strip()).split('\n')
         self.assertEqual(expected, d.listFiles('/mnt/sdcard/tests'))
         self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2/bar'))
 
--- a/testing/mozbase/mozdevice/tests/sut_fileMethods.py
+++ b/testing/mozbase/mozdevice/tests/sut_fileMethods.py
@@ -1,13 +1,13 @@
 #!/usr/bin/env python
 
 import hashlib
 import mozdevice
-import mozlog
+import logging
 import shutil
 import tempfile
 import unittest
 from sut import MockAgent
 
 
 class TestFileMethods(unittest.TestCase):
     """ Class to test misc file methods """
@@ -22,51 +22,51 @@ class TestFileMethods(unittest.TestCase)
         with tempfile.NamedTemporaryFile() as f:
             f.write(self.content)
             f.flush()
 
             # Test Valid Hashes
             commands_valid = [("hash /sdcard/test/file", self.temp_hash)]
 
             m = MockAgent(self, commands=commands_valid)
-            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
             self.assertTrue(d.validateFile('/sdcard/test/file', f.name))
 
             # Test invalid hashes
             commands_invalid = [("hash /sdcard/test/file", "0this0hash0is0completely0invalid")]
 
             m = MockAgent(self, commands=commands_invalid)
-            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
             self.assertFalse(d.validateFile('/sdcard/test/file', f.name))
 
     def test_getFile(self):
 
         fname = "/mnt/sdcard/file"
         commands = [("pull %s" % fname, "%s,%s\n%s" % (fname, len(self.content), self.content)),
                     ("hash %s" % fname, self.temp_hash)]
 
         with tempfile.NamedTemporaryFile() as f:
             m = MockAgent(self, commands=commands)
-            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+            d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
             # No error means success
             self.assertEqual(None, d.getFile(fname, f.name))
 
     def test_getDirectory(self):
 
         fname = "/mnt/sdcard/file"
         commands = [("isdir /mnt/sdcard", "TRUE"),
                     ("isdir /mnt/sdcard", "TRUE"),
                     ("cd /mnt/sdcard", ""),
                     ("ls", "file"),
                     ("isdir %s" % fname, "FALSE"),
                     ("pull %s" % fname, "%s,%s\n%s" % (fname, len(self.content), self.content)),
                     ("hash %s" % fname, self.temp_hash)]
 
         tmpdir = tempfile.mkdtemp()
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual(None, d.getDirectory("/mnt/sdcard", tmpdir))
 
         # Cleanup
         shutil.rmtree(tmpdir)
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_info.py
+++ b/testing/mozbase/mozdevice/tests/sut_info.py
@@ -1,11 +1,11 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import re
 import unittest
 from sut import MockAgent
 
 
 class TestGetInfo(unittest.TestCase):
 
     commands = {'os': ('info os', 'JDQ39'),
@@ -31,17 +31,17 @@ class TestGetInfo(unittest.TestCase):
                 'sutuserinfo': ('info sutuserinfo', 'User Serial:0'),
                 'temperature': ('info temperature', 'Temperature: unknown')
                 }
 
     def test_getInfo(self):
 
         for directive in self.commands.keys():
             m = MockAgent(self, commands=[self.commands[directive]])
-            d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=mozlog.DEBUG)
+            d = mozdevice.DroidSUT('127.0.0.1', port=m.port, logLevel=logging.DEBUG)
 
             expected = re.sub(r'\ +', ' ', self.commands[directive][1]).split('\n')
             # Account for slightly different return format for 'process'
             if directive is 'process':
                 expected = [[x] for x in expected]
 
             self.assertEqual(d.getInfo(directive=directive)[directive], expected)
 
--- a/testing/mozbase/mozdevice/tests/sut_ip.py
+++ b/testing/mozbase/mozdevice/tests/sut_ip.py
@@ -1,11 +1,11 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestGetIP(unittest.TestCase):
     """ class to test IP methods """
 
     commands = [('exec ifconfig eth0', 'eth0: ip 192.168.0.1 '
@@ -15,23 +15,23 @@ class TestGetIP(unittest.TestCase):
                  'mask 255.255.0.0 flags [up broadcast running multicast]\n'
                  'return code [0]'),
                 ('exec ifconfig fake0', '##AGENT-WARNING## [ifconfig] '
                  'command with arg(s) = [fake0] is currently not implemented.')
                 ]
 
     def test_getIP_eth0(self):
         m = MockAgent(self, commands=[self.commands[0]])
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual('192.168.0.1', d.getIP(interfaces=['eth0']))
 
     def test_getIP_wlan0(self):
         m = MockAgent(self, commands=[self.commands[1]])
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual('10.1.39.126', d.getIP(interfaces=['wlan0']))
 
     def test_getIP_error(self):
         m = MockAgent(self, commands=[self.commands[2]])
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertRaises(mozdevice.DMError, d.getIP, interfaces=['fake0'])
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_kill.py
+++ b/testing/mozbase/mozdevice/tests/sut_kill.py
@@ -1,24 +1,24 @@
 #!/usr/bin/env python
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestKill(unittest.TestCase):
 
     def test_killprocess(self):
         commands = [("ps", "1000    1486    com.android.settings\n"
                            "10016   420 com.android.location.fused\n"
                            "10023   335 com.android.systemui\n"),
                     ("kill com.android.settings",
                      "Successfully killed com.android.settings\n")]
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         # No error raised means success
         self.assertEqual(None,  d.killProcess("com.android.settings"))
 
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_list.py
+++ b/testing/mozbase/mozdevice/tests/sut_list.py
@@ -1,22 +1,22 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestListFiles(unittest.TestCase):
     commands = [("isdir /mnt/sdcard", "TRUE"),
                 ("cd /mnt/sdcard", ""),
                 ("ls", "Android\nMusic\nPodcasts\nRingtones\nAlarms\n"
                        "Notifications\nPictures\nMovies\nDownload\nDCIM\n")]
 
     def test_listFiles(self):
         m = MockAgent(self, commands=self.commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
 
         expected = (self.commands[2][1].strip()).split("\n")
         self.assertEqual(expected, d.listFiles("/mnt/sdcard"))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_logcat.py
+++ b/testing/mozbase/mozdevice/tests/sut_logcat.py
@@ -1,12 +1,12 @@
 #!/usr/bin/env python
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestLogCat(unittest.TestCase):
     """ Class to test methods associated with logcat """
 
     def test_getLogcat(self):
@@ -30,22 +30,22 @@ class TestLogCat(unittest.TestCase):
         "return code [0]")
 
         inp = ("execsu /system/bin/logcat -v time -d "
         "dalvikvm:I ConnectivityService:S WifiMonitor:S "
         "WifiStateTracker:S wpa_supplicant:S NetworkStateTracker:S")
 
         commands = [(inp, logcat_output)]
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual(logcat_output[:-17].replace('\r\n', '\n').splitlines(True), d.getLogcat())
 
     def test_recordLogcat(self):
 
         commands = [("execsu /system/bin/logcat -c", "return code [0]")]
 
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         # No error raised means success
         self.assertEqual(None, d.recordLogcat())
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_mkdir.py
+++ b/testing/mozbase/mozdevice/tests/sut_mkdir.py
@@ -1,13 +1,13 @@
 # Any copyright is dedicated to the Public Domain.
 # http://creativecommons.org/publicdomain/zero/1.0/
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 class MkDirsTest(unittest.TestCase):
 
     def test_mkdirs(self):
         subTests = [{'cmds': [('isdir /mnt/sdcard/baz/boop', 'FALSE'),
                               ('info os', 'android'),
@@ -30,17 +30,17 @@ class MkDirsTest(unittest.TestCase):
                      'expectException': True},
                      ]
         for subTest in subTests:
             a = MockAgent(self, commands=subTest['cmds'])
 
             exceptionThrown = False
             try:
                 d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
-                                       logLevel=mozlog.DEBUG)
+                                       logLevel=logging.DEBUG)
                 d.mkDirs('/mnt/sdcard/baz/boop/bip')
             except mozdevice.DMError:
                 exceptionThrown = True
             self.assertEqual(exceptionThrown, subTest['expectException'])
 
             a.wait()
 
     def test_repeated_path_part(self):
@@ -53,24 +53,24 @@ class MkDirsTest(unittest.TestCase):
                 ('info os', 'android'),
                 ('isdir /mnt', 'TRUE'),
                 ('isdir /mnt/sdcard', 'TRUE'),
                 ('isdir /mnt/sdcard/foo', 'FALSE'),
                 ('mkdr /mnt/sdcard/foo',
                  '/mnt/sdcard/foo successfully created')]
         a = MockAgent(self, commands=cmds)
         d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
-                               logLevel=mozlog.DEBUG)
+                               logLevel=logging.DEBUG)
         d.mkDirs('/mnt/sdcard/foo/foo')
         a.wait()
 
     def test_mkdirs_on_root(self):
         cmds = [('isdir /', 'TRUE')]
         a = MockAgent(self, commands=cmds)
         d = mozdevice.DroidSUT('127.0.0.1', port=a.port,
-                               logLevel=mozlog.DEBUG)
+                               logLevel=logging.DEBUG)
         d.mkDirs('/foo')
 
         a.wait()
 
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_movetree.py
+++ b/testing/mozbase/mozdevice/tests/sut_movetree.py
@@ -1,62 +1,62 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
 # 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/.
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 class MoveTreeTest(unittest.TestCase):
     def test_moveFile(self):
         commands = [('mv /mnt/sdcard/tests/test.txt /mnt/sdcard/tests/test1.txt', ''),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'test1.txt'),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'test1.txt')]
 
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/test.txt',
                 '/mnt/sdcard/tests/test1.txt'))
         self.assertFalse(d.fileExists('/mnt/sdcard/tests/test.txt'))
         self.assertTrue(d.fileExists('/mnt/sdcard/tests/test1.txt'))
 
     def test_moveDir(self):
         commands = [("mv /mnt/sdcard/tests/foo /mnt/sdcard/tests/bar", ""),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'bar')]
 
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/foo',
                 '/mnt/sdcard/tests/bar'))
         self.assertTrue(d.fileExists('/mnt/sdcard/tests/bar'))
 
     def test_moveNonEmptyDir(self):
         commands = [('isdir /mnt/sdcard/tests/foo/bar', 'TRUE'),
                     ('mv /mnt/sdcard/tests/foo /mnt/sdcard/tests/foo2', ''),
                     ('isdir /mnt/sdcard/tests', 'TRUE'),
                     ('cd /mnt/sdcard/tests', ''),
                     ('ls', 'foo2'),
                     ('isdir /mnt/sdcard/tests/foo2', 'TRUE'),
                     ('cd /mnt/sdcard/tests/foo2', ''),
                     ('ls', 'bar')]
 
         m = MockAgent(self, commands=commands)
         d = mozdevice.DroidSUT("127.0.0.1", port=m.port,
-                logLevel=mozlog.DEBUG)
+                logLevel=logging.DEBUG)
 
         self.assertTrue(d.dirExists('/mnt/sdcard/tests/foo/bar'))
         self.assertEqual(None, d.moveTree('/mnt/sdcard/tests/foo',
                 '/mnt/sdcard/tests/foo2'))
         self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2'))
         self.assertTrue(d.fileExists('/mnt/sdcard/tests/foo2/bar'))
 
 if __name__ == "__main__":
--- a/testing/mozbase/mozdevice/tests/sut_pull.py
+++ b/testing/mozbase/mozdevice/tests/sut_pull.py
@@ -1,11 +1,11 @@
 from sut import MockAgent
 import mozdevice
-import mozlog
+import logging
 import unittest
 
 class PullTest(unittest.TestCase):
 
     def test_pull_success(self):
         for count in [ 1, 4, 1024, 2048 ]:
             cheeseburgers = ""
             for i in range(count):
@@ -15,31 +15,31 @@ class PullTest(unittest.TestCase):
             remoteName = "/mnt/sdcard/cheeseburgers"
             a = MockAgent(self, commands = [("pull %s" % remoteName,
                                              "%s,%s\n%s" % (remoteName,
                                                             len(cheeseburgers),
                                                             cheeseburgers)),
                                             ("isdir /mnt/sdcard", "TRUE")])
 
             d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
-                                   logLevel=mozlog.DEBUG)
+                                   logLevel=logging.DEBUG)
             pulledData = d.pullFile("/mnt/sdcard/cheeseburgers")
             self.assertEqual(pulledData, cheeseburgers)
             d.dirExists('/mnt/sdcard')
 
     def test_pull_failure(self):
 
         # this test simulates only receiving a few bytes of what we expect
         # to be larger file
         remoteName = "/mnt/sdcard/cheeseburgers"
         a = MockAgent(self, commands = [("pull %s" % remoteName,
                                          "%s,15\n%s" % (remoteName,
                                                         "cheeseburgh"))])
         d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
-                               logLevel=mozlog.DEBUG)
+                               logLevel=logging.DEBUG)
         exceptionThrown = False
         try:
             d.pullFile("/mnt/sdcard/cheeseburgers")
         except mozdevice.DMError:
             exceptionThrown = True
         self.assertTrue(exceptionThrown)
 
 if __name__ == '__main__':
--- a/testing/mozbase/mozdevice/tests/sut_push.py
+++ b/testing/mozbase/mozdevice/tests/sut_push.py
@@ -1,12 +1,12 @@
 from sut import MockAgent
 import mozfile
 import mozdevice
-import mozlog
+import logging
 import unittest
 import hashlib
 import tempfile
 import os
 
 class PushTest(unittest.TestCase):
 
     def test_push(self):
@@ -68,17 +68,17 @@ class PushTest(unittest.TestCase):
                      ]
 
         for subTest in subTests:
             a = MockAgent(self, commands = subTest['cmds'])
 
             exceptionThrown = False
             try:
                 d = mozdevice.DroidSUT("127.0.0.1", port=a.port,
-                                       logLevel=mozlog.DEBUG)
+                                       logLevel=logging.DEBUG)
                 d.pushDir(tempdir, "/mnt/sdcard")
             except mozdevice.DMError:
                 exceptionThrown = True
             self.assertEqual(exceptionThrown, subTest['expectException'])
 
             a.wait()
 
         # FIXME: delete directory when done
--- a/testing/mozbase/mozdevice/tests/sut_remove.py
+++ b/testing/mozbase/mozdevice/tests/sut_remove.py
@@ -1,24 +1,24 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestRemove(unittest.TestCase):
 
     def test_removeDir(self):
         commands = [("isdir /mnt/sdcard/test", "TRUE"),
                     ("rmdr /mnt/sdcard/test", "Deleting file(s) from "
                                             "/storage/emulated/legacy/Moztest\n"
                                             "        <empty>\n"
                                             "Deleting directory "
                                             "/storage/emulated/legacy/Moztest\n")]
 
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         # No error implies we're all good
         self.assertEqual(None, d.removeDir("/mnt/sdcard/test"))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_time.py
+++ b/testing/mozbase/mozdevice/tests/sut_time.py
@@ -1,18 +1,18 @@
 #/usr/bin/env python
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestGetCurrentTime(unittest.TestCase):
 
     def test_getCurrentTime(self):
         command = [('clok', '1349980200')]
 
         m = MockAgent(self, commands=command)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         self.assertEqual(d.getCurrentTime(), int(command[0][1]))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozdevice/tests/sut_unpackfile.py
+++ b/testing/mozbase/mozdevice/tests/sut_unpackfile.py
@@ -1,23 +1,23 @@
 #!/usr/bin/env python
 
 import mozdevice
-import mozlog
+import logging
 import unittest
 from sut import MockAgent
 
 
 class TestUnpack(unittest.TestCase):
 
     def test_unpackFile(self):
 
         commands = [("unzp /data/test/sample.zip /data/test/",
                      "Checksum:          653400271\n"
                      "1 of 1 successfully extracted\n")]
         m = MockAgent(self, commands=commands)
-        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=mozlog.DEBUG)
+        d = mozdevice.DroidSUT("127.0.0.1", port=m.port, logLevel=logging.DEBUG)
         # No error being thrown imples all is well
         self.assertEqual(None, d.unpackFile("/data/test/sample.zip",
                                             "/data/test/"))
 
 if __name__ == '__main__':
     unittest.main()
--- a/testing/mozbase/mozlog/mozlog/__init__.py
+++ b/testing/mozbase/mozlog/mozlog/__init__.py
@@ -1,26 +1,25 @@
 # 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/.
+# 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/.
 
 """
-Mozlog aims to standardize log formatting within Mozilla.
+Mozlog aims to standardize log handling and formatting within Mozilla.
+
+It implements a JSON-based structured logging protocol with convenience
+facilities for recording test results.
 
-It simply wraps Python's logging_ module and adds a few convenience methods
-for logging test results and events.
-
-The structured submodule takes a different approach and implements a
-JSON-based logging protocol designed for recording test results."""
+The old unstructured module is deprecated. It simply wraps Python's
+logging_ module and adds a few convenience methods for logging test
+results and events.
+"""
 
-from logger import *
-from loglistener import LogMessageServer
-from loggingmixin import LoggingMixin
+import sys
 
-try:
-    import structured
-except ImportError:
-    # Structured logging doesn't work on python 2.6 which is still used on some
-    # legacy test machines; https://bugzilla.mozilla.org/show_bug.cgi?id=864866
-    # Once we move away from Python 2.6, please cleanup devicemanager.py's
-    # exception block
-    pass
+from . import commandline
+from . import structuredlog
+from . import unstructured
+from .structuredlog import get_default_logger, set_default_logger
 
+# Backwards compatibility shim for consumers that use mozlog.structured
+structured = sys.modules[__name__]
+sys.modules['{}.structured'.format(__name__)] = structured
rename from testing/mozbase/mozlog/mozlog/structured/commandline.py
rename to testing/mozbase/mozlog/mozlog/commandline.py
--- a/testing/mozbase/mozlog/mozlog/structured/commandline.py
+++ b/testing/mozbase/mozlog/mozlog/commandline.py
@@ -1,21 +1,21 @@
 # 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/.
 
 import argparse
 import optparse
 import os
 import sys
+from collections import defaultdict
 
-from collections import defaultdict
-from structuredlog import StructuredLogger, set_default_logger
-import handlers
-import formatters
+from . import handlers
+from . import formatters
+from .structuredlog import StructuredLogger, set_default_logger
 
 log_formatters = {
     'raw': (formatters.JSONFormatter, "Raw structured log messages"),
     'unittest': (formatters.UnittestFormatter, "Unittest style output"),
     'xunit': (formatters.XUnitFormatter, "xUnit compatible XML"),
     'html': (formatters.HTMLFormatter, "HTML report"),
     'mach': (formatters.MachFormatter, "Human-readable output"),
     'tbpl': (formatters.TbplFormatter, "TBPL style log format"),
@@ -165,17 +165,17 @@ def setup_handlers(logger, formatters, f
             logger.add_handler(handler)
 
 
 def setup_logging(suite, args, defaults=None, formatter_defaults=None):
     """
     Configure a structuredlogger based on command line arguments.
 
     The created structuredlogger will also be set as the default logger, and
-    can be retrieved with :py:func:`~mozlog.structured.structuredlog.get_default_logger`.
+    can be retrieved with :py:func:`~mozlog.get_default_logger`.
 
     :param suite: The name of the testsuite being run
     :param args: A dictionary of {argument_name:value} produced from
                  parsing the command line arguments for the application
     :param defaults: A dictionary of {formatter name: output stream} to apply
                      when there is no logging supplied on the command line. If
                      this isn't supplied, reasonable defaults are chosen
                      (coloured mach formatting if stdout is a terminal, or raw
rename from testing/mozbase/mozlog/mozlog/structured/formatters/__init__.py
rename to testing/mozbase/mozlog/mozlog/formatters/__init__.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/base.py
rename to testing/mozbase/mozlog/mozlog/formatters/base.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/errorsummary.py
rename to testing/mozbase/mozlog/mozlog/formatters/errorsummary.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/html/__init__.py
rename to testing/mozbase/mozlog/mozlog/formatters/html/__init__.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/html/html.py
rename to testing/mozbase/mozlog/mozlog/formatters/html/html.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/html/main.js
rename to testing/mozbase/mozlog/mozlog/formatters/html/main.js
rename from testing/mozbase/mozlog/mozlog/structured/formatters/html/style.css
rename to testing/mozbase/mozlog/mozlog/formatters/html/style.css
rename from testing/mozbase/mozlog/mozlog/structured/formatters/html/xmlgen.py
rename to testing/mozbase/mozlog/mozlog/formatters/html/xmlgen.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/machformatter.py
rename to testing/mozbase/mozlog/mozlog/formatters/machformatter.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/tbplformatter.py
rename to testing/mozbase/mozlog/mozlog/formatters/tbplformatter.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/unittest.py
rename to testing/mozbase/mozlog/mozlog/formatters/unittest.py
rename from testing/mozbase/mozlog/mozlog/structured/formatters/xunit.py
rename to testing/mozbase/mozlog/mozlog/formatters/xunit.py
rename from testing/mozbase/mozlog/mozlog/structured/handlers/__init__.py
rename to testing/mozbase/mozlog/mozlog/handlers/__init__.py
rename from testing/mozbase/mozlog/mozlog/structured/handlers/base.py
rename to testing/mozbase/mozlog/mozlog/handlers/base.py
rename from testing/mozbase/mozlog/mozlog/structured/handlers/bufferhandler.py
rename to testing/mozbase/mozlog/mozlog/handlers/bufferhandler.py
rename from testing/mozbase/mozlog/mozlog/structured/handlers/statushandler.py
rename to testing/mozbase/mozlog/mozlog/handlers/statushandler.py
--- a/testing/mozbase/mozlog/mozlog/structured/handlers/statushandler.py
+++ b/testing/mozbase/mozlog/mozlog/handlers/statushandler.py
@@ -2,17 +2,17 @@
 # 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 collections import (
     defaultdict,
     namedtuple,
 )
 
-from mozlog.structured.structuredlog import log_levels
+from mozlog.structuredlog import log_levels
 
 RunSummary = namedtuple("RunSummary",
                         ("unexpected_statuses",
                          "expected_statuses",
                          "log_level_counts",
                          "action_counts"))
 
 class StatusHandler(object):
rename from testing/mozbase/mozlog/mozlog/structured/logtypes.py
rename to testing/mozbase/mozlog/mozlog/logtypes.py
rename from testing/mozbase/mozlog/mozlog/structured/reader.py
rename to testing/mozbase/mozlog/mozlog/reader.py
rename from testing/mozbase/mozlog/mozlog/structured/scripts/__init__.py
rename to testing/mozbase/mozlog/mozlog/scripts/__init__.py
rename from testing/mozbase/mozlog/mozlog/structured/scripts/format.py
rename to testing/mozbase/mozlog/mozlog/scripts/format.py
rename from testing/mozbase/mozlog/mozlog/structured/scripts/logmerge.py
rename to testing/mozbase/mozlog/mozlog/scripts/logmerge.py
--- a/testing/mozbase/mozlog/mozlog/structured/scripts/logmerge.py
+++ b/testing/mozbase/mozlog/mozlog/scripts/logmerge.py
@@ -1,16 +1,16 @@
 from __future__ import print_function
 import argparse
 import json
 import os
 import sys
 from threading import current_thread
 import time
-from mozlog.structured.reader import read
+from mozlog.reader import read
 
 
 def dump_entry(entry, output):
     json.dump(entry, output)
     output.write("\n")
 
 
 def fill_process_info(event):
@@ -74,9 +74,9 @@ def main(**kwargs):
             dump_entry(entry, output)
 
 
 
 if __name__ == "__main__":
     parser = get_parser()
     args = parser.parse_args()
     kwargs = vars(args)
-    main(**kwargs)
\ No newline at end of file
+    main(**kwargs)
rename from testing/mozbase/mozlog/mozlog/structured/scripts/unstable.py
rename to testing/mozbase/mozlog/mozlog/scripts/unstable.py
--- a/testing/mozbase/mozlog/mozlog/structured/scripts/unstable.py
+++ b/testing/mozbase/mozlog/mozlog/scripts/unstable.py
@@ -1,13 +1,13 @@
 import argparse
 from collections import defaultdict
 import json
 
-from mozlog.structured import reader
+from mozlog import reader
 
 class StatusHandler(reader.LogHandler):
     def __init__(self):
         self.run_info = None
         self.statuses = defaultdict(lambda:defaultdict(lambda:defaultdict(lambda: defaultdict(int))))
 
     def test_id(self, test):
         if type(test) in (str, unicode):
rename from testing/mozbase/mozlog/mozlog/structured/stdadapter.py
rename to testing/mozbase/mozlog/mozlog/stdadapter.py
deleted file mode 100644
--- a/testing/mozbase/mozlog/mozlog/structured/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# 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/.
-
-import commandline
-import structuredlog
-from structuredlog import get_default_logger, set_default_logger
rename from testing/mozbase/mozlog/mozlog/structured/structuredlog.py
rename to testing/mozbase/mozlog/mozlog/structuredlog.py
--- a/testing/mozbase/mozlog/mozlog/structured/structuredlog.py
+++ b/testing/mozbase/mozlog/mozlog/structuredlog.py
@@ -75,17 +75,17 @@ def get_default_logger(component=None):
 
     return StructuredLogger(_default_logger_name, component=component)
 
 def set_default_logger(default_logger):
     """Sets the default logger to logger.
 
     It can then be retrieved with :py:func:`get_default_logger`
 
-    Note that :py:func:`~mozlog.structured.commandline.setup_logging` will
+    Note that :py:func:`~mozlog.commandline.setup_logging` will
     set a default logger for you, so there should be no need to call this
     function if you're using setting up logging that way (recommended).
 
     :param default_logger: The logger to set to default.
     """
     global _default_logger_name
 
     _default_logger_name = default_logger.name
new file mode 100644
--- /dev/null
+++ b/testing/mozbase/mozlog/mozlog/unstructured/__init__.py
@@ -0,0 +1,7 @@
+# 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 .logger import *
+from .loglistener import LogMessageServer
+from .loggingmixin import LoggingMixin
rename from testing/mozbase/mozlog/mozlog/logger.py
rename to testing/mozbase/mozlog/mozlog/unstructured/logger.py
rename from testing/mozbase/mozlog/mozlog/loggingmixin.py
rename to testing/mozbase/mozlog/mozlog/unstructured/loggingmixin.py
--- a/testing/mozbase/mozlog/mozlog/loggingmixin.py
+++ b/testing/mozbase/mozlog/mozlog/unstructured/loggingmixin.py
@@ -1,33 +1,36 @@
 # 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/.
 
-import mozlog
+from .logger import (
+    Logger,
+    getLogger,
+)
+
 
 class LoggingMixin(object):
     """Expose a subset of logging functions to an inheriting class."""
 
     def set_logger(self, logger_instance=None, name=None):
         """Method for setting the underlying logger instance to be used."""
 
-        if logger_instance and not isinstance(logger_instance, mozlog.Logger):
-            raise ValueError("logger_instance must be an instance of" +
-                             "mozlog.Logger")
+        if logger_instance and not isinstance(logger_instance, Logger):
+            raise ValueError("logger_instance must be an instance of Logger")
 
         if name is None:
             name = ".".join([self.__module__, self.__class__.__name__])
 
-        self._logger = logger_instance or mozlog.getLogger(name)
+        self._logger = logger_instance or getLogger(name)
 
     def _log_msg(self, cmd, *args, **kwargs):
         if not hasattr(self, "_logger"):
-            self._logger = mozlog.getLogger(".".join([self.__module__,
-                                                      self.__class__.__name__]))
+            self._logger = getLogger(".".join([self.__module__,
+                                               self.__class__.__name__]))
         getattr(self._logger, cmd)(*args, **kwargs)
 
     def log(self, *args, **kwargs):
         self._log_msg("log", *args, **kwargs)
 
     def info(self, *args, **kwargs):
         self._log_msg("info", *args, **kwargs)
 
rename from testing/mozbase/mozlog/mozlog/loglistener.py
rename to testing/mozbase/mozlog/mozlog/unstructured/loglistener.py
--- a/testing/mozbase/mozlog/setup.py
+++ b/testing/mozbase/mozlog/setup.py
@@ -1,16 +1,16 @@
 # 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 setuptools import setup, find_packages
 
 PACKAGE_NAME = 'mozlog'
-PACKAGE_VERSION = '2.11'
+PACKAGE_VERSION = '3.0'
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
       description="Robust log handling specialized for logging in the Mozilla universe",
       long_description="see http://mozbase.readthedocs.org/",
       author='Mozilla Automation and Testing Team',
       author_email='tools@lists.mozilla.org',
       url='https://wiki.mozilla.org/Auto-tools/Projects/Mozbase',
@@ -22,15 +22,15 @@ setup(name=PACKAGE_NAME,
       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',
                   ],
-      package_data={"mozlog.structured": ["formatters/html/main.js",
-                                          "formatters/html/style.css"]},
+      package_data={"mozlog": ["formatters/html/main.js",
+                               "formatters/html/style.css"]},
       entry_points={
           "console_scripts": [
-              "structlog = mozlog.structured.scripts:main"
+              "structlog = mozlog.scripts:main"
           ]}
      )
--- a/testing/mozbase/mozlog/tests/test_logger.py
+++ b/testing/mozbase/mozlog/tests/test_logger.py
@@ -6,17 +6,17 @@ import datetime
 import json
 import socket
 import threading
 import time
 import unittest
 
 import mozfile
 
-import mozlog
+import mozlog.unstructured as mozlog
 
 class ListHandler(mozlog.Handler):
     """Mock handler appends messages to a list for later inspection."""
 
     def __init__(self):
         mozlog.Handler.__init__(self)
         self.messages = []
 
--- a/testing/mozbase/mozlog/tests/test_structured.py
+++ b/testing/mozbase/mozlog/tests/test_structured.py
@@ -5,17 +5,17 @@ import optparse
 import os
 import StringIO
 import sys
 import unittest
 import xml.etree.ElementTree as ET
 
 import mozfile
 
-from mozlog.structured import (
+from mozlog import (
     commandline,
     reader,
     structuredlog,
     stdadapter,
     handlers,
     formatters,
 )
 
--- a/testing/mozbase/moznetwork/moznetwork/moznetwork.py
+++ b/testing/mozbase/moznetwork/moznetwork/moznetwork.py
@@ -7,30 +7,29 @@ import array
 import re
 import socket
 import struct
 import subprocess
 import sys
 
 import mozinfo
 import mozlog
-from mozlog import structured
 
 if mozinfo.isLinux:
     import fcntl
 
 
 class NetworkError(Exception):
     """Exception thrown when unable to obtain interface or IP."""
 
 
 def _get_logger():
-    logger = structured.get_default_logger(component='moznetwork')
+    logger = mozlog.get_default_logger(component='moznetwork')
     if not logger:
-        logger = mozlog.getLogger('moznetwork')
+        logger = mozlog.unstructured.getLogger('moznetwork')
     return logger
 
 
 def _get_interface_list():
     """Provides a list of available network interfaces
        as a list of tuples (name, ip)"""
     logger = _get_logger()
     logger.debug('Gathering interface list')
--- a/testing/mozbase/moznetwork/setup.py
+++ b/testing/mozbase/moznetwork/setup.py
@@ -2,17 +2,17 @@
 # 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 setuptools import setup
 
 PACKAGE_VERSION = '0.26'
 
 deps = ['mozinfo',
-        'mozlog >= 2.11',
+        'mozlog >= 3.0',
         ]
 
 setup(name='moznetwork',
       version=PACKAGE_VERSION,
       description="Library of network utilities for use in Mozilla testing",
       long_description="see http://mozbase.readthedocs.org/",
       classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
       keywords='mozilla',
--- a/testing/mozbase/mozprofile/mozprofile/addons.py
+++ b/testing/mozbase/mozprofile/mozprofile/addons.py
@@ -5,25 +5,25 @@
 import os
 import shutil
 import sys
 import tempfile
 import urllib2
 import zipfile
 from xml.dom import minidom
 
+import mozfile
 from manifestparser import ManifestParser
-import mozfile
-import mozlog
+from mozlog.unstructured import getLogger
 
 # Needed for the AMO's rest API - https://developer.mozilla.org/en/addons.mozilla.org_%28AMO%29_API_Developers%27_Guide/The_generic_AMO_API
 AMO_API_VERSION = "1.5"
 
 # Logger for 'mozprofile.addons' module
-module_logger = mozlog.getLogger(__name__)
+module_logger = getLogger(__name__)
 
 
 class AddonFormatError(Exception):
     """Exception for not well-formed add-on manifest files"""
 
 
 class AddonManager(object):
     """
--- a/testing/mozbase/mozprofile/setup.py
+++ b/testing/mozbase/mozprofile/setup.py
@@ -8,17 +8,17 @@ from setuptools import setup
 PACKAGE_NAME = 'mozprofile'
 PACKAGE_VERSION = '0.24'
 
 # we only support python 2 right now
 assert sys.version_info[0] == 2
 
 deps = ['manifestparser >= 0.6',
         'mozfile >= 1.0',
-        'mozlog']
+        'mozlog >= 3.0']
 
 setup(name=PACKAGE_NAME,
       version=PACKAGE_VERSION,
       description="Library to create and modify Mozilla application profiles",
       long_description="see http://mozbase.readthedocs.org/",
       classifiers=['Environment :: Console',
                    'Intended Audience :: Developers',
                    'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)',
--- a/testing/mozbase/mozprofile/tests/test_addons.py
+++ b/testing/mozbase/mozprofile/tests/test_addons.py
@@ -8,17 +8,17 @@ import os
 import shutil
 import tempfile
 import unittest
 import urllib2
 
 from manifestparser import ManifestParser
 import mozfile
 import mozhttpd
-import mozlog
+import mozlog.unstructured as mozlog
 import mozprofile
 
 from addon_stubs import generate_addon, generate_manifest
 
 
 here = os.path.dirname(os.path.abspath(__file__))
 
 
--- a/testing/mozbase/mozrunner/mozrunner/base/runner.py
+++ b/testing/mozbase/mozrunner/mozrunner/base/runner.py
@@ -3,17 +3,17 @@
 # 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 abc import ABCMeta, abstractproperty
 import os
 import subprocess
 import traceback
 
-from mozlog.structured import get_default_logger
+from mozlog import get_default_logger
 from mozprocess import ProcessHandler
 import mozcrash
 
 from ..application import DefaultContext
 from ..errors import RunnerNotStartedError
 
 
 class BaseRunner(object):
--- a/testing/mozbase/mozrunner/setup.py
+++ b/testing/mozbase/mozrunner/setup.py
@@ -9,17 +9,17 @@ PACKAGE_NAME = 'mozrunner'
 PACKAGE_VERSION = '6.7'
 
 desc = """Reliable start/stop/configuration of Mozilla Applications (Firefox, Thunderbird, etc.)"""
 
 deps = ['mozcrash >= 0.14',
         'mozdevice >= 0.37',
         'mozfile >= 1.0',
         'mozinfo >= 0.7',
-        'mozlog >= 1.5',
+        'mozlog >= 3.0',
         'mozprocess >= 0.17',
         'mozprofile >= 0.18',
         ]
 
 # we only support python 2 right now
 assert sys.version_info[0] == 2
 
 setup(name=PACKAGE_NAME,
--- a/testing/mozbase/mozversion/mozversion/mozversion.py
+++ b/testing/mozbase/mozversion/mozversion/mozversion.py
@@ -10,31 +10,30 @@ import re
 import sys
 import tempfile
 import xml.dom.minidom
 import zipfile
 
 import mozdevice
 import mozfile
 import mozlog
-from mozlog import structured
 
 import errors
 
 
 INI_DATA_MAPPING = (('application', 'App'), ('platform', 'Build'))
 
 
 class Version(object):
 
     def __init__(self):
         self._info = {}
-        self._logger = structured.get_default_logger(component='mozversion')
+        self._logger = mozlog.get_default_logger(component='mozversion')
         if not self._logger:
-            self._logger = mozlog.getLogger('mozversion')
+            self._logger = mozlog.unstructured.getLogger('mozversion')
 
     def get_gecko_info(self, path):
         for type, section in INI_DATA_MAPPING:
             config_file = os.path.join(path, "%s.ini" % type)
             if os.path.exists(config_file):
                 self._parse_ini_file(open(config_file), type, section)
             else:
                 self._logger.warning('Unable to find %s' % config_file)
--- a/testing/mozbase/mozversion/setup.py
+++ b/testing/mozbase/mozversion/setup.py
@@ -3,17 +3,17 @@
 # You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from setuptools import setup
 
 PACKAGE_VERSION = '1.2'
 
 dependencies = ['mozdevice >= 0.44',
                 'mozfile >= 1.0',
-                'mozlog >= 2.11']
+                'mozlog >= 3.0']
 
 setup(name='mozversion',
       version=PACKAGE_VERSION,
       description='Library to get version information for applications',
       long_description='See http://mozbase.readthedocs.org',
       classifiers=[],
       keywords='mozilla',
       author='Mozilla Automation and Testing Team',
--- a/testing/mozbase/test.py
+++ b/testing/mozbase/test.py
@@ -12,17 +12,17 @@ by default https://github.com/mozilla/mo
 import imp
 import manifestparser
 import mozinfo
 import optparse
 import os
 import sys
 import unittest
 
-from mozlog import structured
+import mozlog
 from moztest.results import TestResultCollection
 from moztest.adapters.unit import StructuredTestRunner
 
 here = os.path.dirname(os.path.abspath(__file__))
 
 def unittests(path):
     """return the unittests in a .py file"""
 
@@ -46,23 +46,20 @@ def main(args=sys.argv[1:]):
     usage = '%prog [options] manifest.ini <manifest.ini> <...>'
     parser = optparse.OptionParser(usage=usage, description=__doc__)
     parser.add_option('-b', "--binary",
                   dest="binary", help="Binary path",
                   metavar=None, default=None)
     parser.add_option('--list', dest='list_tests',
                       action='store_true', default=False,
                       help="list paths of tests to be run")
-    structured.commandline.add_logging_group(parser)
+    mozlog.commandline.add_logging_group(parser)
     options, args = parser.parse_args(args)
-    logger = structured.commandline.setup_logging("mozbase",
-                                                  options,
-                                                  {
-                                                      "tbpl": sys.stdout
-                                                  })
+    logger = mozlog.commandline.setup_logging("mozbase", options,
+                                              {"tbpl": sys.stdout})
 
     # read the manifest
     if args:
         manifests = args
     else:
         manifests = [os.path.join(here, 'test-manifest.ini')]
     missing = []
     for manifest in manifests:
--- a/testing/mozharness/mozharness/mozilla/structuredlog.py
+++ b/testing/mozharness/mozharness/mozilla/structuredlog.py
@@ -25,31 +25,31 @@ class StructuredOutputParser(OutputParse
             self.strict = kwargs.pop('strict')
         else:
             self.strict = True
 
         self.suite_category = kwargs.pop('suite_category', None)
 
         super(StructuredOutputParser, self).__init__(**kwargs)
 
-        structured = self._get_mozlog_module()
-        self.formatter = structured.formatters.TbplFormatter()
-        self.handler = structured.handlers.StatusHandler()
-        self.log_actions = structured.structuredlog.log_actions()
+        mozlog = self._get_mozlog_module()
+        self.formatter = mozlog.formatters.TbplFormatter()
+        self.handler = mozlog.handlers.StatusHandler()
+        self.log_actions = mozlog.structuredlog.log_actions()
 
         self.worst_log_level = INFO
         self.tbpl_status = TBPL_SUCCESS
 
     def _get_mozlog_module(self):
         try:
-            from mozlog import structured
+            import mozlog
         except ImportError:
             self.fatal("A script class using structured logging must inherit "
                        "from the MozbaseMixin to ensure that mozlog is available.")
-        return structured
+        return mozlog
 
     def _handle_unstructured_output(self, line):
         if self.strict:
             self.critical(("Test harness output was not a valid structured log message: "
                           "\n%s") % line)
             self.update_levels(TBPL_FAILURE, log.CRITICAL)
             return
         super(StructuredOutputParser, self).parse_single_line(line)
--- a/testing/remotecppunittests.py
+++ b/testing/remotecppunittests.py
@@ -7,20 +7,20 @@
 import os, sys
 import subprocess
 import tempfile
 from zipfile import ZipFile
 import runcppunittests as cppunittests
 import mozcrash
 import mozfile
 import mozinfo
+import mozlog
 import StringIO
 import posixpath
 from mozdevice import devicemanager, devicemanagerADB, devicemanagerSUT
-from mozlog import structured
 
 try:
     from mozbuild.base import MozbuildObject
     build_obj = MozbuildObject.from_environment()
 except ImportError:
     build_obj = None
 
 class RemoteCPPUnitTests(cppunittests.CPPUnitTests):
@@ -203,17 +203,17 @@ class RemoteCPPUnittestOptions(cppunitte
                     type = "string", dest = "add_env",
                     help = "additional remote environment variable definitions (eg. --addEnv \"somevar=something\")")
         defaults["add_env"] = None
 
         self.set_defaults(**defaults)
 
 def main():
     parser = RemoteCPPUnittestOptions()
-    structured.commandline.add_logging_group(parser)
+    mozlog.commandline.add_logging_group(parser)
     options, args = parser.parse_args()
     if not args:
         print >>sys.stderr, """Usage: %s <test binary> [<test binary>...]""" % sys.argv[0]
         sys.exit(1)
     if options.local_lib is not None and not os.path.isdir(options.local_lib):
         print >>sys.stderr, """Error: --localLib directory %s not found""" % options.local_lib
         sys.exit(1)
     if options.local_apk is not None and not os.path.isfile(options.local_apk):
@@ -244,20 +244,18 @@ def main():
                 runner.wait()
             raise
     else:
         dm = devicemanagerSUT.DeviceManagerSUT(options.device_ip, options.device_port, deviceRoot=options.remote_test_root)
         if not options.device_ip:
             print "Error: you must provide a device IP to connect to via the --deviceIP option"
             sys.exit(1)
 
-    log = structured.commandline.setup_logging("remotecppunittests",
-                                               options,
-                                               {"tbpl": sys.stdout})
-
+    log = mozlog.commandline.setup_logging("remotecppunittests", options,
+                                           {"tbpl": sys.stdout})
 
     options.xre_path = os.path.abspath(options.xre_path)
     cppunittests.update_mozinfo()
     progs = cppunittests.extract_unittests_from_args(args, mozinfo.info)
     tester = RemoteCPPUnitTests(dm, options, progs)
     try:
         result = tester.run_tests(progs, options.xre_path, options.symbols_path)
     except Exception, e:
--- a/testing/runcppunittests.py
+++ b/testing/runcppunittests.py
@@ -7,18 +7,18 @@
 from __future__ import with_statement
 import sys, os, tempfile, shutil
 from optparse import OptionParser
 import manifestparser
 import mozprocess
 import mozinfo
 import mozcrash
 import mozfile
+import mozlog
 from contextlib import contextmanager
-from mozlog import structured
 from subprocess import PIPE
 
 SCRIPT_DIR = os.path.abspath(os.path.realpath(os.path.dirname(__file__)))
 
 class CPPUnitTests(object):
     # Time (seconds) to wait for test process to complete
     TEST_PROC_TIMEOUT = 900
     # Time (seconds) in which process will be killed if it produces no output.
@@ -137,17 +137,17 @@ class CPPUnitTests(object):
         * xre_path: A path to a directory containing a XUL Runtime Environment.
         * symbols_path: A path to a directory containing Breakpad-formatted
                         symbol files for producing stack traces on crash.
 
         Returns True if all test programs exited with a zero status, False
         otherwise.
         """
         self.xre_path = xre_path
-        self.log = structured.structuredlog.get_default_logger()
+        self.log = mozlog.get_default_logger()
         self.log.suite_start(programs)
         env = self.build_environment()
         pass_count = 0
         fail_count = 0
         for prog in programs:
             single_result = self.run_one_test(prog, env, symbols_path, interactive)
             if single_result:
                 pass_count += 1
@@ -210,28 +210,27 @@ def update_mozinfo():
         if path in dirs:
             break
         dirs.add(path)
         path = os.path.split(path)[0]
     mozinfo.find_and_update_from_json(*dirs)
 
 def main():
     parser = CPPUnittestOptions()
-    structured.commandline.add_logging_group(parser)
+    mozlog.commandline.add_logging_group(parser)
     options, args = parser.parse_args()
     if not args:
         print >>sys.stderr, """Usage: %s <test binary> [<test binary>...]""" % sys.argv[0]
         sys.exit(1)
     if not options.xre_path:
         print >>sys.stderr, """Error: --xre-path is required"""
         sys.exit(1)
 
-    log = structured.commandline.setup_logging("cppunittests",
-                                               options,
-                                               {"tbpl": sys.stdout})
+    log = mozlog.commandline.setup_logging("cppunittests", options,
+                                           {"tbpl": sys.stdout})
 
     update_mozinfo()
     progs = extract_unittests_from_args(args, mozinfo.info)
     options.xre_path = os.path.abspath(options.xre_path)
     if mozinfo.isMac:
         options.xre_path = os.path.join(os.path.dirname(options.xre_path), 'Resources')
     tester = CPPUnitTests()
 
--- a/testing/web-platform/harness/docs/usage.rst
+++ b/testing/web-platform/harness/docs/usage.rst
@@ -149,21 +149,21 @@ locations.
 The content of the ``wptrunner.default.ini`` default configuration file
 makes wptrunner look for tests (that is, a web-platform-tests checkout)
 as a subdirectory of the current directory named ``tests``, and for
 metadata files in a subdirectory of the current directory named ``meta``.
 
 Output
 ------
 
-wptrunner uses the :py:mod:`mozlog.structured` package for output. This
+wptrunner uses the :py:mod:`mozlog` package for output. This
 structures events such as test results or log messages as JSON objects
 that can then be fed to other tools for interpretation. More details
 about the message format are given in the
-:py:mod:`mozlog.structured` documentation.
+:py:mod:`mozlog` documentation.
 
 By default the raw JSON messages are dumped to stdout. This is
 convenient for piping into other tools, but not ideal for humans
 reading the output. :py:mod:`mozlog` comes with several other
 formatters, which are accessible through command line options. The
 general format of these options is ``--log-name=dest``, where ``name``
 is the name of the format and ``dest`` is a path to a destination
 file, or ``-`` for stdout. The raw JSON data is written by the ``raw``
--- a/testing/web-platform/harness/requirements.txt
+++ b/testing/web-platform/harness/requirements.txt
@@ -1,4 +1,4 @@
 html5lib >= 0.99
 mozinfo >= 0.7
-mozlog >= 2.8
+mozlog >= 3.0
 mozdebug >= 0.1
--- a/testing/web-platform/harness/test/test.py
+++ b/testing/web-platform/harness/test/test.py
@@ -3,19 +3,19 @@ import argparse
 import json
 import os
 import sys
 import tempfile
 import threading
 import time
 from StringIO import StringIO
 
-from mozlog.structured import structuredlog, reader
-from mozlog.structured.handlers import BaseHandler, StreamHandler, StatusHandler
-from mozlog.structured.formatters import MachFormatter
+from mozlog import structuredlog, reader
+from mozlog.handlers import BaseHandler, StreamHandler, StatusHandler
+from mozlog.formatters import MachFormatter
 from wptrunner import wptcommandline, wptrunner
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 def setup_wptrunner_logging(logger):
     structuredlog.set_default_logger(logger)
     wptrunner.logger = logger
     wptrunner.wptlogging.setup_stdlib_logger()
--- a/testing/web-platform/harness/wptrunner/environment.py
+++ b/testing/web-platform/harness/wptrunner/environment.py
@@ -5,17 +5,17 @@
 import json
 import os
 import multiprocessing
 import signal
 import socket
 import sys
 import time
 
-from mozlog.structured import get_default_logger, handlers
+from mozlog import get_default_logger, handlers
 
 from wptlogging import LogLevelRewriter
 
 here = os.path.split(__file__)[0]
 
 serve = None
 sslutils = None
 
--- a/testing/web-platform/harness/wptrunner/metadata.py
+++ b/testing/web-platform/harness/wptrunner/metadata.py
@@ -5,18 +5,18 @@
 import os
 import shutil
 import sys
 import tempfile
 import types
 import uuid
 from collections import defaultdict
 
-from mozlog.structured import reader
-from mozlog.structured import structuredlog
+from mozlog import reader
+from mozlog import structuredlog
 
 import expected
 import manifestupdate
 import testloader
 import wptmanifest
 import wpttest
 from vcs import git
 manifest = None  # Module that will be imported relative to test_root
--- a/testing/web-platform/harness/wptrunner/reduce.py
+++ b/testing/web-platform/harness/wptrunner/reduce.py
@@ -5,17 +5,17 @@
 import sys
 import tempfile
 from cStringIO import StringIO
 from collections import defaultdict
 
 import wptrunner
 import wpttest
 
-from mozlog.structured import commandline, reader
+from mozlog import commandline, reader
 
 logger = None
 
 
 def setup_logging(args, defaults):
     global logger
     logger = commandline.setup_logging("web-platform-tests-unstable", args, defaults)
     wptrunner.setup_stdlib_logger()
--- a/testing/web-platform/harness/wptrunner/testrunner.py
+++ b/testing/web-platform/harness/wptrunner/testrunner.py
@@ -6,17 +6,17 @@ from __future__ import unicode_literals
 
 import multiprocessing
 import sys
 import threading
 import traceback
 from Queue import Empty
 from multiprocessing import Process, current_process, Queue
 
-from mozlog.structured import structuredlog
+from mozlog import structuredlog
 
 # Special value used as a sentinal in various commands
 Stop = object()
 
 
 class MessageLogger(object):
     def __init__(self, message_func):
         self.send_message = message_func
--- a/testing/web-platform/harness/wptrunner/tests/test_update.py
+++ b/testing/web-platform/harness/wptrunner/tests/test_update.py
@@ -1,17 +1,17 @@
 # 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/.
 
 import unittest
 import StringIO
 
 from .. import metadata, manifestupdate
-from mozlog.structured import structuredlog, handlers, formatters
+from mozlog import structuredlog, handlers, formatters
 
 
 class TestExpectedUpdater(unittest.TestCase):
     def create_manifest(self, data, test_path="path/to/test.ini"):
         f = StringIO.StringIO(data)
         return manifestupdate.compile(f, test_path)
 
     def create_updater(self, data, **kwargs):
--- a/testing/web-platform/harness/wptrunner/vcs.py
+++ b/testing/web-platform/harness/wptrunner/vcs.py
@@ -1,16 +1,16 @@
 # 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/.
 
 import subprocess
 from functools import partial
 
-from mozlog.structured import get_default_logger
+from mozlog import get_default_logger
 
 logger = None
 
 def vcs(bin_name):
     def inner(command, *args, **kwargs):
         global logger
 
         if logger is None:
--- a/testing/web-platform/harness/wptrunner/wptcommandline.py
+++ b/testing/web-platform/harness/wptrunner/wptcommandline.py
@@ -30,17 +30,17 @@ def require_arg(kwargs, name, value_func
         value_func = lambda x: x is not None
 
     if not name in kwargs or not value_func(kwargs[name]):
         print >> sys.stderr, "Missing required argument %s" % name
         sys.exit(1)
 
 
 def create_parser(product_choices=None):
-    from mozlog.structured import commandline
+    from mozlog import commandline
 
     import products
 
     if product_choices is None:
         config_data = config.load()
         product_choices = products.products_enabled(config_data)
 
     parser = argparse.ArgumentParser(description="Runner for web-platform-tests tests.")
--- a/testing/web-platform/harness/wptrunner/wptlogging.py
+++ b/testing/web-platform/harness/wptrunner/wptlogging.py
@@ -3,17 +3,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import logging
 import sys
 import threading
 from StringIO import StringIO
 from multiprocessing import Queue
 
-from mozlog.structured import commandline, stdadapter
+from mozlog import commandline, stdadapter
 
 def setup(args, defaults):
     logger = commandline.setup_logging("web-platform-tests", args, defaults)
     setup_stdlib_logger()
 
     for name in args.keys():
         if name.startswith("log_"):
             args.pop(name)
--- a/testing/web-platform/update/__init__.py
+++ b/testing/web-platform/update/__init__.py
@@ -2,17 +2,17 @@
 # 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/.
 
 #!/usr/bin/env python
 import os
 import subprocess
 import sys
 
-from mozlog.structured import structuredlog
+from mozlog import structuredlog
 
 here = os.path.split(__file__)[0]
 
 sys.path.insert(0, os.path.abspath(os.path.join(here, os.pardir, "harness")))
 sys.path.insert(0, os.path.abspath(os.path.join(here, os.pardir, "tests", "tools", "scripts")))
 
 from wptrunner.update import setup_logging, WPTUpdate
 from wptrunner.update.base import exit_unclean
--- a/testing/xpcshell/remotexpcshelltests.py
+++ b/testing/xpcshell/remotexpcshelltests.py
@@ -5,18 +5,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import posixpath
 import sys, os
 import subprocess
 import runxpcshelltests as xpcshell
 import tempfile
 from zipfile import ZipFile
-from mozlog import structured
-from mozlog.structured import commandline
+from mozlog import commandline
 import shutil
 import mozdevice
 import mozfile
 import mozinfo
 
 here = os.path.dirname(os.path.abspath(__file__))
 
 def remoteJoin(path1, path2):
@@ -590,17 +589,17 @@ class PathMapping:
 
 def main():
 
     if sys.version_info < (2,7):
         print >>sys.stderr, "Error: You must use python version 2.7 or newer but less than 3.0"
         sys.exit(1)
 
     parser = RemoteXPCShellOptions()
-    structured.commandline.add_logging_group(parser)
+    commandline.add_logging_group(parser)
     options, args = parser.parse_args()
     if not options.localAPK:
         for file in os.listdir(os.path.join(options.objdir, "dist")):
             if (file.endswith(".apk") and file.startswith("fennec")):
                 options.localAPK = os.path.join(options.objdir, "dist")
                 options.localAPK = os.path.join(options.localAPK, file)
                 print >>sys.stderr, "using APK: " + options.localAPK
                 break
--- a/testing/xpcshell/runtestsb2g.py
+++ b/testing/xpcshell/runtestsb2g.py
@@ -6,18 +6,17 @@
 
 import sys
 import os
 sys.path.insert(0, os.path.abspath(os.path.realpath(os.path.dirname(sys.argv[0]))))
 
 import traceback
 from remotexpcshelltests import RemoteXPCShellTestThread, XPCShellRemote, RemoteXPCShellOptions
 from mozdevice import devicemanagerADB, DMError
-from mozlog import structured
-from mozlog.structured import commandline
+from mozlog import commandline
 
 DEVICE_TEST_ROOT = '/data/local/tests'
 
 
 from marionette import Marionette
 
 class B2GXPCShellTestThread(RemoteXPCShellTestThread):
     # Overridden
@@ -209,17 +208,17 @@ def run_remote_xpcshell(parser, options,
             sys.exit(1)
     except:
         print "Automation Error: Exception caught while running tests"
         traceback.print_exc()
         sys.exit(1)
 
 def main():
     parser = B2GOptions()
-    structured.commandline.add_logging_group(parser)
+    commandline.add_logging_group(parser)
     options, args = parser.parse_args()
     log = commandline.setup_logging("Remote XPCShell",
                                     options,
                                     {"tbpl": sys.stdout})
     run_remote_xpcshell(parser, options, args, log)
 
 # You usually run this like :
 # python runtestsb2g.py --emulator arm --b2gpath $B2GPATH --manifest $MANIFEST [--xre-path $MOZ_HOST_BIN
--- a/testing/xpcshell/runxpcshelltests.py
+++ b/testing/xpcshell/runxpcshelltests.py
@@ -58,17 +58,17 @@ here = os.path.dirname(__file__)
 mozbase = os.path.realpath(os.path.join(os.path.dirname(here), 'mozbase'))
 
 if os.path.isdir(mozbase):
     for package in os.listdir(mozbase):
         sys.path.append(os.path.join(mozbase, package))
 
 from manifestparser import TestManifest
 from manifestparser.filters import chunk_by_slice, tags
-from mozlog import structured
+from mozlog import commandline
 import mozcrash
 import mozinfo
 
 # --------------------------------------------------------------
 
 # TODO: perhaps this should be in a more generally shared location?
 # This regex matches all of the C0 and C1 control characters
 # (U+0000 through U+001F; U+007F; U+0080 through U+009F),
@@ -553,18 +553,17 @@ class XPCShellTestThread(Thread):
         if not output:
             return
         self.log.info(">>>>>>>")
         for line in output:
             self.log_line(line)
         self.log.info("<<<<<<<")
 
     def report_message(self, message):
-        """Stores or logs a json log message in mozlog.structured
-        format."""
+        """Stores or logs a json log message in mozlog format."""
         if self.verbose:
             self.log_line(message)
         else:
             # Tests eligible to retry will never dump their buffered output.
             if not self.retry:
                 self.output_lines.append(message)
 
     def process_line(self, line_string):
@@ -1537,23 +1536,21 @@ class XPCShellOptions(OptionParser):
         self.add_option("--utility-path",
                         action="store", dest="utility_path",
                         default=None,
                         help="Path to a directory containing utility programs, such "
                              "as stack fixer scripts.")
 
 def main():
     parser = XPCShellOptions()
-    structured.commandline.add_logging_group(parser)
+    commandline.add_logging_group(parser)
     options, args = parser.parse_args()
 
 
-    log = structured.commandline.setup_logging("XPCShell",
-                                               options,
-                                               {"tbpl": sys.stdout})
+    log = commandline.setup_logging("XPCShell", options, {"tbpl": sys.stdout})
 
     if len(args) < 2 and options.manifest is None or \
        (len(args) < 1 and options.manifest is not None):
         print >>sys.stderr, """Usage: %s <path to xpcshell> <test dirs>
               or: %s --manifest=test.manifest <path to xpcshell>""" % (sys.argv[0],
                                                               sys.argv[0])
         sys.exit(1)