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
3
View Complete Implementation : app.py
Copyright MIT License
Author : wistbean
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
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
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
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
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
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
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
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
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)