twisted.logger.formatTime - python examples

Here are the examples of the python api twisted.logger.formatTime taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

6 Examples 7

3 View Complete Implementation : logger.py
Copyright GNU Affero General Public License v3.0
Author : daq-tools
def logObserver(outFile, timeFormat=timeFormatRFC3339):
    def formatEvent(event):
        return formatLogEvent(
            event, formatTime=lambda e: formatTime(e, timeFormat)
        )

    return FileLogObserver(outFile, formatEvent)

0 View Complete Implementation : upgrade.py
Copyright Apache License 2.0
Author : apple
def main(argv=sys.argv, stderr=sys.stderr, reactor=None):
    """
    Do the export.
    """
    from twistedcaldav.config import config
    if reactor is None:
        from twisted.internet import reactor

    options = UpgradeOptions()
    try:
        options.parseOptions(argv[1:])
    except UsageError, e:
        usage(e)

    try:
        output = options.openOutput()
    except IOError, e:
        stderr.write("Unable to open output file for writing: %s\n" % (e))
        sys.exit(1)

    if options.merge:
        def setMerge(data):
            data.MergeUpgrades = True
        config.addPostUpdateHooks([setMerge])

    def makeService(store):
        return UpgraderService(store, options, output, reactor, config)

    def onlyUpgradeEvents(eventDict):
        text = formatEvent(eventDict)
        output.write(formatTime(eventDict.get("log_time", time.time())) + " " + text + "\n")
        output.flush()

    if not options["status"] and not options["check"]:
        # When doing an upgrade always send L{LogLevel.warn} logging to the tool output
        log.observer.addObserver(FilteringLogObserver(
            onlyUpgradeEvents,
            [LogLevelFilterPredicate(defaultLogLevel=LogLevel.warn), ]
        ))

    def customServiceMaker():
        customService = CalDAVServiceMaker()
        customService.doPostImport = options["postprocess"]
        return customService

    def _patchConfig(config):
        config.FailIfUpgradeNeeded = options["status"] or options["check"]
        config.CheckExistingSchema = options["check"]
        if options["prefix"]:
            config.UpgradeHomePrefix = options["prefix"]
        if not options["status"] and not options["check"]:
            config.DefaultLogLevel = "debug"

    def _onShutdown():
        if not UpgraderService.started:
            print("Failed to start service.")

    utilityMain(options["config"], makeService, reactor, customServiceMaker, patchConfig=_patchConfig, onShutdown=_onShutdown, verbose=options["debug"])

0 View Complete Implementation : logger.py
Copyright GNU Affero General Public License v3.0
Author : daq-tools
def formatLogEvent(event, formatTime=formatTime):
    eventText = formatEvent(event)
    if not eventText:
        return None

    eventText = eventText.replace(u"\n", u"\n\t")
    timeStamp = formatTime(event.get("log_time", None))

    system = event.get("log_system", None)

    if system is None:
        level = event.get("log_level", None)
        if level is None:
            levelName = u"-"
        else:
            levelName = level.name

        system = u"{namespace}".format(
            namespace=event.get("log_namespace", u"-"),
        )
    else:
        try:
            system = unicode(system)
        except Exception:
            system = u"UNFORMATTABLE"

    return u"{timeStamp} [{system}] {level}: {event}\n".format(
        timeStamp=timeStamp,
        system=system.ljust(35),
        level=levelName.upper().ljust(8),
        event=eventText,
    )

0 View Complete Implementation : test__twisted.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_format_basics(self):
        thing1 = factory.make_name("thing")
        thing2 = factory.make_name("thing")
        log_system = factory.make_name("system")
        log_format = ">{thing1}< >{thing2}<"
        log_time = pick_log_time()
        self.astertThat(
            _formatModernEvent(
                {
                    "log_time": log_time,
                    "log_format": log_format,
                    "log_system": log_system,
                    "log_level": self.log_level,
                    "thing1": thing1,
                    "thing2": thing2,
                }
            ),
            Equals(
                "%s %s: [%s] >%s< >%s<\n"
                % (
                    logger.formatTime(log_time, DEFAULT_LOG_FORMAT_DATE),
                    log_system,
                    self.log_level.name,
                    thing1,
                    thing2,
                )
            ),
        )

0 View Complete Implementation : test__twisted.py
Copyright GNU Affero General Public License v3.0
Author : maas
    def test_format_failure(self):
        try:
            1 / 0
        except ZeroDivisionError:
            failure = Failure()
        else:
            raise RuntimeError("should have raised ZeroDivisionError")
        log_system = factory.make_name("system")
        log_time = pick_log_time()
        self.astertThat(
            _formatModernEvent(
                {
                    "log_time": log_time,
                    "log_system": log_system,
                    "log_level": self.log_level,
                    "log_failure": failure,
                }
            ),
            Equals(
                "%s %s: [%s] \n\t%s\n"
                % (
                    logger.formatTime(log_time, DEFAULT_LOG_FORMAT_DATE),
                    log_system,
                    self.log_level.name,
                    failure.getTraceback().replace("\n", "\n\t"),
                )
            ),
        )

0 View Complete Implementation : logger.py
Copyright GNU General Public License v2.0
Author : TheTorProject
def log_event_format(event):
    return u"{0} [{1}]: {2}\n".format(formatTime(event["log_time"]),
                                      event["log_level"].name.upper(),
                                      formatEvent(event))