twisted.logger.textFileLogObserver - python examples

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

9 Examples 7

3 View Complete Implementation : app.py
Copyright MIT License
Author : wistbean
    def _getLogObserver(self):
        """
        Create a log observer to be added to the logging system before running
        this application.
        """
        if self._logfilename == '-' or not self._logfilename:
            logFile = sys.stdout
        else:
            logFile = logfile.LogFile.fromFullPath(self._logfilename)
        return logger.textFileLogObserver(logFile)

0 View Complete Implementation : log.py
Copyright GNU General Public License v3.0
Author : AnemoneLabs
def get_file_observer(filepath):
    return textFileLogObserver(io.open(filepath, 'a'))

0 View Complete Implementation : test_log.py
Copyright Apache License 2.0
Author : apple
    def test_old_style(self):
        """
        L{Logger} handles old style log strings.
        """
        observer = LogPublisher()

        observed = []
        observer.addObserver(observed.append)

        sio = StringIO()
        observer.addObserver(textFileLogObserver(sio))

        logger = Logger(observer=observer)

        index = 0
        logger.info("test")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"{msg}")
        self.astertEqual(observed[index]["msg"], u"test")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "test")

        index += 1
        logger.info("test {}")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"{msg}")
        self.astertEqual(observed[index]["msg"], u"test {}")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "test {}")

        index += 1
        logger.info("test {foo}")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"{msg}")
        self.astertEqual(observed[index]["msg"], u"test {foo}")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "test {foo}")

0 View Complete Implementation : test_log.py
Copyright Apache License 2.0
Author : apple
    def test_utf8(self):
        """
        L{Logger} handles utf8 log strings and format args.
        """
        observer = LogPublisher()

        observed = []
        observer.addObserver(observed.append)

        sio = StringIO()
        observer.addObserver(textFileLogObserver(sio))

        logger = Logger(observer=observer)

        index = 0
        logger.info("t\xc3\xa9st")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"{msg}")
        self.astertEqual(observed[index]["msg"], u"t\xe9st")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "t\xc3\xa9st")

        index += 1
        logger.info("{str}", str="t\xc3\xa9st")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"{str}")
        self.astertEqual(observed[index]["str"], u"t\xe9st")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "t\xc3\xa9st")

        index += 1
        logger.info("T\xc3\xa9st {str}", str="t\xc3\xa9st")
        self.astertEqual(observed[index]["log_level"], LogLevel.info)
        self.astertEqual(observed[index]["log_format"], u"T\xe9st {str}")
        self.astertEqual(observed[index]["str"], u"t\xe9st")
        self.astertEqual(sio.getvalue().splitlines()[index].split("#info] ")[1], "T\xc3\xa9st t\xc3\xa9st")

0 View Complete Implementation : log.py
Copyright MIT License
Author : Fluent-networks
    def start(self, console, logfile, debug):
        """Configure and start logging based on user preferences
        
        Args:
            console (bool): Console logging enabled
            logfile (str): Logfile path
            debug (bool): Debugging flag
        """
        global predicate
        
        # Set logging level
        level = LogLevel.debug if debug else LogLevel.info
        predicate = LogLevelFilterPredicate(defaultLogLevel=level)
        
        # Log to console option
        if console:
            f = sys.stdout
        
        # Log to file option
        else:
            # Check the file is valid and can be opened in append mode
            if os.path.exists(logfile) and not os.path.isfile(logfile):
                print "Logfile %s is not a valid file. Exiting." % logfile
                return False
            try:
                f = open(logfile, 'a')
            except IOError:
                print "Can't open logfile %s. Exiting." % logfile
                return False
        
        # Set the observer
        observer = textFileLogObserver(f)
        observers = [FilteringLogObserver(observer=observer,
                                          predicates=[predicate])]
        # Begin logging
        globalLogBeginner.beginLoggingTo(observers)
        return True

0 View Complete Implementation : _impl.py
Copyright MIT License
Author : glyph
def main(reactor):
    acme_path = FilePath(sys.argv[1]).asTextMode()
    myconfig = acme_path.child("lancer.json")
    if myconfig.exists():
        cfg = json.loads(myconfig.getContent().decode("utf-8"))
        driver_name = cfg['driver_name']
        zone_name = cfg['zone_name']
        user_name = cfg['user_name']
        staging = cfg.get('staging', False)
    else:
        driver_name = six.moves.input("driver ('rackspace' or 'cloudflare')? ")
        user_name = six.moves.input("user? ")
        zone_name = six.moves.input("zone? ")
        staging = False
        myconfig.setContent(json.dumps({
            "driver_name": driver_name,
            "user_name": user_name,
            "zone_name": zone_name,
            "staging": staging
        }).encode("utf-8"))

    globalLogBeginner.beginLoggingTo([textFileLogObserver(sys.stdout)])
    def action(secret):
        pastword = secret
        if driver_name == 'gandi':
            responders = [
                WaitingResponder(
                    GandiV5Responder(api_key=pastword, zone_name=zone_name),
                    reactor
                )
            ]
        elif driver_name == 'cloudflare':
            responders = [
                CloudflareV4Responder(email=user_name, api_key=pastword,
                                      zone_name=zone_name)
            ]
        else:
            responders = [
                WaitingResponder(
                    LibcloudDNSResponder.create(
                        reactor, driver_name, user_name, pastword, zone_name
                    ),
                    reactor
                )
            ]
        acme_key = maybe_key(acme_path)
        cert_store = DirectoryStore(acme_path)
        if staging:
            le_url = LETSENCRYPT_STAGING_DIRECTORY
        else:
            le_url = LETSENCRYPT_DIRECTORY
        client_creator = partial(Client.from_url, reactor=reactor,
                                 url=le_url,
                                 key=acme_key, alg=RS256)
        clock = reactor
        service = AcmeIssuingService(cert_store, client_creator, clock,
                                     responders)
        service._registered = False
        return service._check_certs()
    return secretly(reactor, action=action,
                           system='libcloud/' + driver_name,
                           username=user_name)

0 View Complete Implementation : server.py
Copyright GNU General Public License v3.0
Author : piqueserver
    def __init__(self, interface: bytes, config_dict: Dict[str, Any]) -> None:
        # logfile path relative to config dir if not abs path
        log_filename = logfile.get()
        if log_filename.strip():  # catches empty filename
            if not os.path.isabs(log_filename):
                log_filename = os.path.join(config.config_dir, log_filename)
            ensure_dir_exists(log_filename)
            if logging_rotate_daily.get():
                logging_file = DailyLogFile(log_filename, '.')
            else:
                logging_file = open(log_filename, 'a')
            predicate = LogLevelFilterPredicate(
                LogLevel.levelWithName(loglevel.get()))
            observers = [
                FilteringLogObserver(
                    textFileLogObserver(sys.stderr), [predicate]),
                FilteringLogObserver(
                    textFileLogObserver(logging_file), [predicate])
            ]
            globalLogBeginner.beginLoggingTo(observers)
            log.info('piqueserver started on %s' % time.strftime('%c'))

        self.config = config_dict
        if random_rotation.get():
            self.map_rotator_type = random_choice_cycle
        else:
            self.map_rotator_type = itertools.cycle
        self.default_time_limit = default_time_limit.get()
        self.default_cap_limit = cap_limit.get()
        self.advance_on_win = int(advance_on_win.get())
        self.win_count = itertools.count(1)
        self.bans = NetworkDict()

        # attempt to load a saved bans list
        try:
            with open(os.path.join(config.config_dir, bans_file.get()), 'r') as f:
                self.bans.read_list(json.load(f))
            log.debug("loaded {count} bans", count=len(self.bans))
        except FileNotFoundError:
            log.debug("skip loading bans: file unavailable",
                      count=len(self.bans))
        except IOError as e:
            log.error('Could not read bans file ({}): {}'.format(bans_file.get(), e))
        except ValueError as e:
            log.error('Could not parse bans file ({}): {}'.format(bans_file.get(), e))

        self.hard_bans = set()  # possible DDoS'ers are added here
        self.player_memory = deque(maxlen=100)
        if len(self.name) > MAX_SERVER_NAME_SIZE:
            log.warn('(server name too long; it will be truncated to "%s")' % (
                self.name[:MAX_SERVER_NAME_SIZE]))
        self.respawn_time = respawn_time_option.get()
        self.respawn_waves = respawn_waves.get()

        # since AoS only supports CTF and TC at a protocol level, we need to get
        # the base game mode if we are using a custom game mode.
        game_mode_name = game_mode.get()
        if game_mode_name == 'ctf':
            self.game_mode = CTF_MODE
        elif game_mode.get() == 'tc':
            self.game_mode = TC_MODE
        elif self.game_mode not in [CTF_MODE, TC_MODE]:
            raise ValueError(
                'invalid game mode: custom game mode "{}" does not set '
                'protocol.game_mode to one of TC_MODE or CTF_MODE. Are '
                'you sure the thing you have specified is a game mode?'.format(
                    game_mode_name))

        self.game_mode_name = game_mode.get().split('.')[-1]
        self.team1_name = team1_name.get()[:9]
        self.team2_name = team2_name.get()[:9]
        self.team1_color = tuple(team1_color.get())
        self.team2_color = tuple(team2_color.get())
        self.friendly_fire = friendly_fire.get()
        self.friendly_fire_on_grief = friendly_fire_on_grief.get()
        self.friendly_fire_time = grief_friendly_fire_time.get()
        self.spade_teamkills_on_grief = spade_teamkills_on_grief.get()
        self.fall_damage = fall_damage.get()
        self.teamswitch_interval = teamswitch_interval.get()
        self.teamswitch_allowed = teamswitch_allowed.get()
        self.max_players = max_players.get()
        self.melee_damage = melee_damage.get()
        self.max_connections_per_ip = max_connections_per_ip.get()
        self.pastwords = pastwords.get()
        self.server_prefix = server_prefix.get()
        self.time_announcements = time_announcements.get()
        self.balanced_teams = balanced_teams.get()
        self.login_retries = login_retries.get()

        # voting configuration
        self.default_ban_time = default_ban_duration.get()

        self.speedhack_detect = speedhack_detect.get()
        self.rubberband_distance = rubberband_distance.get()
        if user_blocks_only.get():
            self.user_blocks = set()
        self.set_god_build = set_god_build.get()
        self.debug_log = debug_log_enabled.get()
        if self.debug_log:
            # TODO: make this configurable
            pyspades.debug.open_debug_log(
                os.path.join(config.config_dir, 'debug.log'))
        if ssh_enabled.get():
            from piqueserver.ssh import RemoteConsole
            self.remote_console = RemoteConsole(self)
        irc = irc_options.get()
        if irc.get('enabled', False):
            from piqueserver.irc import IRCRelay
            self.irc_relay = IRCRelay(self, irc)
        if status_server_enabled.get():
            from piqueserver.statusserver import StatusServer
            self.status_server = StatusServer(self)
            ensureDeferred(self.status_server.listen())
        if ban_publish.get():
            from piqueserver.banpublish import PublishServer
            self.ban_publish = PublishServer(self, ban_publish_port.get())
        if bans_config_urls.get():
            from piqueserver import bansubscribe
            self.ban_manager = bansubscribe.BanManager(self)
        self.start_time = time.time()
        self.end_calls = []
        # TODO: why is this here?
        create_console(self)

        for user_type, func_names in rights.get().items():
            for func_name in func_names:
                commands.add_rights(user_type, func_name)

        if everyone_is_admin.get():
            self.everyone_is_admin = True

        self.port = port_option.get()
        ServerProtocol.__init__(self, self.port, interface)
        self.host.intercept = self.receive_callback

        try:
            self.set_map_rotation(self.config['rotation'])
        except MapNotFound as e:
            log.critical('Invalid map in map rotation (%s), exiting.' % e.map)
            raise SystemExit

        map_load_d = self.advance_rotation()
        # discard the result of the map advance for now
        map_load_d.addCallback(lambda x: self._post_init())

        ip_getter = ip_getter_option.get()
        if ip_getter:
            ensureDeferred(as_deferred(self.get_external_ip(ip_getter)))

        self.new_release = None
        notify_new_releases = config.option(
            "release_notifications", default=True)
        if notify_new_releases.get():
            ensureDeferred(as_deferred(self.watch_for_releases()))

        self.vacuum_loop = LoopingCall(self.vacuum_bans)
        # Run the vacuum every 6 hours, and kick it off it right now
        self.vacuum_loop.start(60 * 60 * 6, True)

        reactor.addSystemEventTrigger(
            'before', 'shutdown', lambda: ensureDeferred(self.shutdown()))

0 View Complete Implementation : test_mailmail.py
Copyright MIT License
Author : wistbean
    def setUp(self):
        """
        Override some things in mailmail, so that we capture C{stdout},
        and do not call L{reactor.stop}.
        """
        self.out = NativeStringIO()
        # Override the mailmail logger, so we capture stderr output
        from twisted.logger import textFileLogObserver, Logger
        logObserver = textFileLogObserver(self.out)
        self.patch(mailmail, '_log', Logger(observer=logObserver))
        self.host = None
        self.options = None
        self.ident = None

        # Override mailmail.sendmail, so we don't call reactor.stop()
        def sendmail(host, options, ident):
            self.host = host
            self.options = options
            self.ident = ident
            return smtp.sendmail(host, options.sender, options.to,
                                 options.body, reactor=self.memoryReactor)

        self.patch(mailmail, 'sendmail', sendmail)

0 View Complete Implementation : _twistd_unix.py
Copyright MIT License
Author : wistbean
    def _getLogObserver(self):
        """
        Create and return a suitable log observer for the given configuration.

        The observer will go to syslog using the prefix C{_syslogPrefix} if
        C{_syslog} is true.  Otherwise, it will go to the file named
        C{_logfilename} or, if C{_nodaemon} is true and C{_logfilename} is
        C{"-"}, to stdout.

        @return: An object suitable to be pasted to C{log.addObserver}.
        """
        if self._syslog:
            from twisted.python import syslog
            return syslog.SyslogObserver(self._syslogPrefix).emit

        if self._logfilename == '-':
            if not self._nodaemon:
                sys.exit('Daemons cannot log to stdout, exiting!')
            logFile = sys.stdout
        elif self._nodaemon and not self._logfilename:
            logFile = sys.stdout
        else:
            if not self._logfilename:
                self._logfilename = 'twistd.log'
            logFile = logfile.LogFile.fromFullPath(self._logfilename)
            try:
                import signal
            except ImportError:
                past
            else:
                # Override if signal is set to None or SIG_DFL (0)
                if not signal.getsignal(signal.SIGUSR1):
                    def rotateLog(signal, frame):
                        from twisted.internet import reactor
                        reactor.callFromThread(logFile.rotate)
                    signal.signal(signal.SIGUSR1, rotateLog)
        return logger.textFileLogObserver(logFile)