def main(self):
        """Parse arguments and run the script's main function via ``react``."""
        observer = None
        try:
            if not self.log_directory.exists():
                self.log_directory.makedirs()
            log_path = self.log_directory.child(
                b"%s-%d.log" % (os.path.basename(self.sys_module.argv[0]),
                                os.getpid()))
            log_file = log_path.open("a")
            observer = FileLogObserver(log_file).emit
            addObserver(observer)
            msg("Arguments: %s" % (self.sys_module.argv,))
        except (OSError, IOError):
            pass

        options = self._parse_options(self.sys_module.argv[1:])
        # XXX: We shouldn't be using this private _reactor API. See
        # https://twistedmatrix.com/trac/ticket/6200 and
        # https://twistedmatrix.com/trac/ticket/7527
        self._react(self.script.main, (options,), _reactor=self._reactor)

        # Not strictly necessary, but nice cleanup for tests:
        if observer is not None:
            removeObserver(observer)
            log_file.close()

    def _test_level(self, level, messages_number):
        observer = LevelFileLogObserver(self.log_file, level)
        log.addObserver(observer)

        self.LOG.debug('test debug')
        self.LOG.info('test info')
        self.LOG.warning('test warning')
        self.LOG.error('test error')
        self.LOG.critical('test critical')

        log.removeObserver(observer)

        with open(self.log_path) as f:
            lines = [line.strip() for line in f.readlines()]

        self.assertEqual(len(lines), messages_number)

        for line in lines:
            m = re.match(self.rx, line)
            self.assertIsNotNone(m)

            time, level_name, system, entry_text = m.groups()

            time = datetime.strptime(time, "%Y-%m-%d %H:%M:%S")
            entry_level = logging.getLevelName(level_name)

            self.assertGreaterEqual(entry_level, level)
            self.assertEqual(system, __name__)

            text = "test {0}".format(level_name.lower())
            self.assertEqual(entry_text, text)

 def _remove(self):
     self._added -= 1
     if self._added == 0:
         log.removeObserver(self.gotEvent)
         log._flushErrors = self._oldFE
         log._ignore = self._oldIE
         log._clearIgnores = self._oldCI

    def test_default_item_completed(self):
        item = dict(name='name')
        assert self.pipe.item_completed([], item, self.info) is item

        # Check that failures are logged by default
        fail = Failure(Exception())
        results = [(True, 1), (False, fail)]

        events = []
        txlog.addObserver(events.append)
        new_item = self.pipe.item_completed(results, item, self.info)
        txlog.removeObserver(events.append)
        self.flushLoggedErrors()

        assert new_item is item
        assert len(events) == 1
        assert events[0]['logLevel'] == log.ERROR
        assert events[0]['failure'] is fail

        # disable failure logging and check again
        self.pipe.LOG_FAILED_RESULTS = False
        events = []
        txlog.addObserver(events.append)
        new_item = self.pipe.item_completed(results, item, self.info)
        txlog.removeObserver(events.append)
        self.flushLoggedErrors()
        assert new_item is item
        assert len(events) == 0

    def test_send_catch_log(self):
        test_signal = object()
        handlers_called = set()

        def log_received(event):
            handlers_called.add(log_received)
            assert "error_handler" in event['message'][0]
            assert event['logLevel'] == log.ERROR

        txlog.addObserver(log_received)
        dispatcher.connect(self.error_handler, signal=test_signal)
        dispatcher.connect(self.ok_handler, signal=test_signal)
        result = yield defer.maybeDeferred(self._get_result, test_signal, arg='test',
                                           handlers_called=handlers_called)

        assert self.error_handler in handlers_called
        assert self.ok_handler in handlers_called
        assert log_received in handlers_called
        self.assertEqual(result[0][0], self.error_handler)
        self.assert_(isinstance(result[0][1], Failure))
        self.assertEqual(result[1], (self.ok_handler, "OK"))

        txlog.removeObserver(log_received)
        self.flushLoggedErrors()
        dispatcher.disconnect(self.error_handler, signal=test_signal)
        dispatcher.disconnect(self.ok_handler, signal=test_signal)

 def _tearDownLogFile(self):
     if self._logFileObserver is not None:
         log.removeObserver(self._logFileObserver.emit)
         self._logFileObserver = None
     if self._logFileObject is not None:
         self._logFileObject.close()
         self._logFileObject = None

    def _exit(self, reactor):
        self.triggered = True
        log.removeObserver(self._failure_observer)

        try:
            reactor.stop()
        except error.ReactorNotRunning:
            pass

 def stop(self):
     """
     Remove all log observers previously set up by L{AppLogger.start}.
     """
     log.msg("Server Shut Down.")
     if self._observer is not None:
         log.removeObserver(self._observer)
         self._observer = None

 def stop(self):
     """
     Print twistd stop log message.
     """
     log.msg("Server Shut Down.")
     if self._observer is not None:
         log.removeObserver(self._observer)
         self._observer = None

 def tearDown(self):
     """
     Ensure the log observer added by L{setUp} is removed.
     """
     try:
         log.removeObserver(self.receiver._emit)
     except ValueError:
         # The test removed it already.
         pass

 def test_error_logged_if_deferred_not_supported(self):
     test_handler = lambda: defer.Deferred()
     log_events = []
     txlog.addObserver(log_events.append)
     dispatcher.connect(test_handler, test_signal)
     self.manager.send(test_signal)
     self.failUnless(log_events)
     self.failUnless('Cannot return deferreds from signal handler' in str(log_events))
     txlog.removeObserver(log_events.append)
     dispatcher.disconnect(test_handler, test_signal)

 def signal_handler(self, signo, frame): 
     try:
         log.msg('Rotating log %s' % self.log_filename)
         log.removeObserver(self.log_observer.emit)
         self.log_file.close()
         self.setup_log(self.log_filename)   
     except:
         msg = "Error in signal_handler:\n%s" % traceback.format_exc()
         print msg
         mail.error(msg)     

    def test_write_to_logfile(self):
        with TemporaryDirectory() as tmpdir:
            o = log.CarbonLogObserver()
            o.log_to_dir(tmpdir)
            addObserver(o)
            log.creates('😀😀😀😀 test !!!!')
            removeObserver(o)

            with open(path.join(tmpdir, 'creates.log')) as logfile:
                read_line = logfile.readline()
                self.assertRegexpMatches(read_line, '.*😀😀😀😀 test !!!!')

 def test_error_logged_if_deferred_not_supported(self):
     test_signal = object()
     test_handler = lambda: defer.Deferred()
     log_events = []
     txlog.addObserver(log_events.append)
     dispatcher.connect(test_handler, test_signal)
     send_catch_log(test_signal)
     self.assertTrue(log_events)
     self.assertIn("Cannot return deferreds from signal handler", str(log_events))
     txlog.removeObserver(log_events.append)
     self.flushLoggedErrors()
     dispatcher.disconnect(test_handler, test_signal)

    def remove_log_observer(self, observer=False):
        """
        Remove a twisted.log observer
        
        @type observer: method
        @param observer: The name of the method specified in add_log_observer. If False, the last known log observer added will be removed
        """

        if observer:
            log.removeObserver(observer)
        else:
            log.removeObserver(self.log_observer)

    def stopService(self):
        log.msg("Stopping %s" % self)
        service.MultiService.stopService(self)

        if self.periodic_task:
            self.periodic_task.stop()
            self.periodic_task = None

        if self.log_task:
            self.log_task.stop()
            self.log_task = None

        log.removeObserver(self.emit)

    def disable(self):
        if not self.enabled:
            return

        if self.periodic_task:
            self.periodic_task.stop()
            self.periodic_task = None

        if self.log_task:
            self.log_task.stop()
            self.log_task = None

        log.removeObserver(self.emit)
        self.enabled = False

    def test_connectionLost(self):
        self.connectionLost = False
        def observer(event):
            self.assertTrue(event["isError"])
            self.assertTrue(event["message"])
            self.connectionLost = True

        try:
            log.addObserver(observer)
            self.message.connectionLost()
            self.assertTrue(self.connectionLost)
            self.assertIdentical(self.message.lines, None)
        finally:
            log.removeObserver(observer)

    def emit(self, level, message, **kwargs):
        def observer(eventDict):
            self.eventDict = eventDict

        twistedLogging.addObserver(observer)

        super(TestLogger, self).emit(level, message, **kwargs)

        twistedLogging.removeObserver(observer)

        self.emitted = {
            "level"  : level,
            "message": message,
            "kwargs" : kwargs,
        }

    def close(self, flush_writer=True):

        def set_disconnected():
            self._writer = None
            self._set_state(State.disconnected)

        try:
            twisted_log.removeObserver(self.on_twisted_log)
        except ValueError:
            # it should be safe to call close() multiple times,
            # in this case we are not registered as the observer anymore
            pass

        d = self._close_writer(flush_writer)
        d.addCallback(defer.drop_param, set_disconnected)
        return d