class FluentTraceLogger( object ):
def __init__( self, name, host='localhost', port=24224 ):
if FluentSender is None:
raise Exception("Attempted to use FluentTraceLogger with not Fluent dependency available.")
self.lock = threading.Lock()
self.thread_local = threading.local()
self.name = name
self.sender = FluentSender( self.name, host=host, port=port )
def context_set( self, key, value ):
self.lock.acquire()
if not hasattr( self.thread_local, 'context' ):
self.thread_local.context = {}
self.thread_local.context[key] = value
self.lock.release()
def context_remove( self, key ):
self.lock.acquire()
del self.thread_local.context[key]
self.lock.release()
def log( self, label, time=None, **kwargs ):
self.lock.acquire()
if hasattr( self.thread_local, 'context' ):
kwargs.update( self.thread_local.context )
self.lock.release()
if time is None:
time = int( time.time() )
self.sender.emit_with_time( label, time, kwargs )
class FluentTraceLogger(object):
def __init__(self, name, host='localhost', port=24224):
if FluentSender is None:
raise Exception(
"Attempted to use FluentTraceLogger with not Fluent dependency available."
)
self.lock = threading.Lock()
self.thread_local = threading.local()
self.name = name
self.sender = FluentSender(self.name, host=host, port=port)
def context_set(self, key, value):
self.lock.acquire()
if not hasattr(self.thread_local, 'context'):
self.thread_local.context = {}
self.thread_local.context[key] = value
self.lock.release()
def context_remove(self, key):
self.lock.acquire()
del self.thread_local.context[key]
self.lock.release()
def log(self, label, time=None, **kwargs):
self.lock.acquire()
if hasattr(self.thread_local, 'context'):
kwargs.update(self.thread_local.context)
self.lock.release()
if time is None:
time = int(time.time())
self.sender.emit_with_time(label, time, kwargs)
class FluentTraceLogger( object ):
def __init__( self, name, host='localhost', port=24224 ):
assert FluentSender is not None, FLUENT_IMPORT_MESSAGE
self.lock = threading.Lock()
self.thread_local = threading.local()
self.name = name
self.sender = FluentSender( self.name, host=host, port=port )
def context_set( self, key, value ):
self.lock.acquire()
if not hasattr( self.thread_local, 'context' ):
self.thread_local.context = {}
self.thread_local.context[key] = value
self.lock.release()
def context_remove( self, key ):
self.lock.acquire()
del self.thread_local.context[key]
self.lock.release()
def log( self, label, event_time=None, **kwargs ):
self.lock.acquire()
if hasattr( self.thread_local, 'context' ):
kwargs.update( self.thread_local.context )
self.lock.release()
event_time = event_time or time.time()
self.sender.emit_with_time( label, int(event_time), kwargs )
def loop(fs: sender.FluentSender, connection_id: str, interval: int,
verbose: bool):
while True:
results, timestamp = run_speedtest()
if results:
if not fs.emit_with_time(connection_id, timestamp,
clean_results(results, verbose)):
logger.error("fluent error: %s", fs.last_error)
fs.clear_last_error()
logger.info("Sleeping for %s", interval)
time.sleep(interval)
class LogSenseSender:
def __init__(self,
logsense_token=None,
tag='python',
meta={},
logsense_host=None,
logsense_port=None,
verbose=False,
nanosecond_precision=False):
internal_logger = logging.getLogger('logsense.sender')
self._logsense_token = logsense_token
if logsense_host:
self._logsense_host = logsense_host
else:
self._logsense_host = getenv('LOGSENSE_HOST', 'logs.logsense.com')
if logsense_port:
self._logsense_port = logsense_port
else:
self._logsense_port = int(getenv('LOGSENSE_PORT', '32714'))
if self._logsense_token is None:
self._logger = None
print("LOGSENSE_TOKEN not set - skipping handler")
else:
self._verbose = verbose
self._logger = FluentSender(
tag,
host=self._logsense_host,
ssl_server_hostname=self._logsense_host,
port=self._logsense_port,
use_ssl=True,
verbose=self._verbose)
self._base_dict = self.update_meta(meta)
self.nanosecond_precision = nanosecond_precision
def update_meta(self, new_meta):
self._base_dict = {
**new_meta,
**{
'cs_customer_token': self._logsense_token,
'cs_hostname': socket.gethostname()
}
}
return self._base_dict
def _convert_value_to_known_type(self, value):
if isinstance(value, str):
return value
elif isinstance(value, int):
return value
elif isinstance(value, float):
return value
elif isinstance(value, dict):
return value
elif isinstance(value, list):
return value
else:
# This fixes issues with e.g. NumPy serialization
return str(value)
def emit(self, data={}):
if self._logger:
if isinstance(data, dict):
converted_data = {
key: self._convert_value_to_known_type(value)
for key, value in data.items()
}
else:
converted_data = {'message': str(data)}
self._logger.emit('tag', {**converted_data, **self._base_dict})
def emit_with_time(self, label, timestamp, data):
event_timestamp = EventTime(timestamp)
if self._logger:
if isinstance(data, dict):
converted_data = {
key: self._convert_value_to_known_type(value)
for key, value in data.items()
}
else:
converted_data = {'message': str(data)}
self._logger.emit_with_time(label, event_timestamp, {
**converted_data,
**self._base_dict
})
@property
def last_error(self):
if self._logger:
return self._logger.last_error()
else:
return None
@last_error.setter
def last_error(self, err):
if self._logger:
self._logger.last_error(err)
def clear_last_error(self, _thread_id=None):
if self._logger:
self._logger.clear_last_error(_thread_id)
def close(self):
if self._logger:
self._logger.close()
