def log_it(retry_state): logger.log( log_level, "Starting call to '%s', this is the %s time calling it.", _utils.get_callback_name(retry_state.fn), _utils.to_ordinal(retry_state.attempt_number), )
def after_log(retry_state): logger.info( "Finished call to {callback!r} after {time:.2f}, this was the {attempt} time calling it.", callback=_utils.get_callback_name(retry_state.fn), time=retry_state.seconds_since_start, attempt=_utils.to_ordinal(retry_state.attempt_number), )
def log_it(retry_state): logger.log( log_level, log_tpl, _utils.get_callback_name(retry_state.fn), retry_state.seconds_since_start, _utils.to_ordinal(retry_state.attempt_number), )
def _log_before_retry(func, trial_number): """Before call strategy that logs to some logger the attempt.""" if trial_number > 1: LOG.warning( "Retrying call to '%(func)s' for the %(num)s time", { 'func': tenacity_utils.get_callback_name(func), 'num': tenacity_utils.to_ordinal(trial_number) })
def log_it(retry_state): if retry_state.outcome.failed: verb, value = 'raised', retry_state.outcome.exception() else: verb, value = 'returned', retry_state.outcome.result() logger.log(log_level, "Retrying %s in %s seconds as it %s %s.", _utils.get_callback_name(retry_state.fn), getattr(retry_state.next_action, 'sleep'), verb, value)
def log_it(retry_state): sec = sec_format % _utils.get_callback_name(retry_state.fn) logger.log( log_level, "Finished call to '{0}' after {1}(s), this was the {2} time calling it." .format( sec, retry_state.seconds_since_start, _utils.to_ordinal(retry_state.attempt_number), ), )
def my_before_sleep(retry_state): # Taken & modified from before_sleep_log in tenacity/before_sleep.py if retry_state.outcome.failed: verb, value = 'raised', retry_state.outcome.exception() else: verb, value = 'returned', retry_state.outcome.result() logger.debug( "Retrying %s in %sms (attempt: %s) as it %s %s[%s]." % (get_callback_name(retry_state.fn), int(getattr(retry_state.next_action, 'sleep') * 1000), retry_state.attempt_number, verb, value.__class__.__name__, value))
def before_log(retry_state): if retry_state.outcome.failed: verb, value = "raised", retry_state.outcome.exception() else: verb, value = "returned", retry_state.outcome.result() logger.info( "Retrying {callback} in {sleep} seconds as it {verb} {value}", callback=_utils.get_callback_name(retry_state.fn), sleep=getattr(retry_state.next_action, "sleep"), verb=verb, value=value, )
def _log_after_retry(func, trial_number, trial_time_taken): """After call strategy that logs to some logger the finished attempt.""" # Using inspect to get arguments of the relevant call frames = inspect.trace() formated_args = _get_args_from_frame(frames, 1) if not formated_args: formated_args = "Unknown" LOG.warning("Finished retry of %(func)s for the %(num)s time after " "%(time)0.3f(s) with args: %(args)s", {'func': tenacity_utils.get_callback_name(func), 'num': tenacity_utils.to_ordinal(trial_number), 'time': trial_time_taken, 'args': formated_args})
def log_it(retry_state): if retry_state.outcome.failed: ex = retry_state.outcome.exception() verb, value = 'raised', '%s: %s' % (type(ex).__name__, ex) if exc_info: local_exc_info = get_exc_info_from_future(retry_state.outcome) else: local_exc_info = False else: verb, value = 'returned', retry_state.outcome.result() local_exc_info = False # exc_info does not apply when no exception logger.log(log_level, "Retrying %s in %s seconds as it %s %s.", _utils.get_callback_name(retry_state.fn), getattr(retry_state.next_action, 'sleep'), verb, value, exc_info=local_exc_info)
def log_it(retry_state): if retry_state.outcome.failed: ex = retry_state.outcome.exception() verb, value = "raised", "{0}: {1}".format(type(ex).__name__, ex) if exc_info: local_exc_info = get_exc_info_from_future(retry_state.outcome) else: local_exc_info = False else: verb, value = "returned", retry_state.outcome.result() local_exc_info = False # exc_info does not apply when no exception logger.log( log_level, "Retrying {0} in {1} seconds as it {2} {3}.".format( _utils.get_callback_name(retry_state.fn), getattr(retry_state.next_action, "sleep"), verb, value, ), exc_info=local_exc_info, )
def log_it(retry_state): logger.log(log_level, log_tpl, _utils.get_callback_name(retry_state.fn), retry_state.seconds_since_start, _utils.to_ordinal(retry_state.attempt_number))
def log_it(func, trial_number, trial_time_taken): logger.log(log_level, log_tpl, _utils.get_callback_name(func), trial_time_taken, _utils.to_ordinal(trial_number))
def log_it(retry_obj, sleep, last_result): logger.log(log_level, "Retrying %s in %d seconds as it raised %s.", _utils.get_callback_name(retry_obj.fn), sleep, last_result.exception())
def _log_before_retry(func, trial_number): """Before call strategy that logs to some logger the attempt.""" if trial_number > 1: LOG.warning("Retrying call to '%(func)s' for the %(num)s time", {'func': tenacity_utils.get_callback_name(func), 'num': tenacity_utils.to_ordinal(trial_number)})
def log_it(retry_state): logger.log(log_level, "Starting call to '%s', this is the %s time calling it.", _utils.get_callback_name(retry_state.fn), _utils.to_ordinal(retry_state.attempt_number))
def warn_about_dunder_non_retry_state_deprecation(fn, stacklevel): msg = ( '"%s" method must be called with' ' single "retry_state" parameter' % (_utils.get_callback_name(fn))) warn(msg, DeprecationWarning, stacklevel=stacklevel + 1)
def warn_about_non_retry_state_deprecation(cbname, func, stacklevel): msg = ( '"%s" function must accept single "retry_state" parameter,' ' please update %s' % (cbname, _utils.get_callback_name(func))) warn(msg, DeprecationWarning, stacklevel=stacklevel + 1)
def log_it(func, trial_number): logger.log(log_level, "Starting call to '%s', this is the %s time calling it.", _utils.get_callback_name(func), _utils.to_ordinal(trial_number))
def log_it(func, trial_number, trial_time_taken): logger.log(log_level, "Finished call to '%s' after %i(ms), " "this was the %s time calling it.", _utils.get_callback_name(func), trial_time_taken, _utils.to_ordinal(trial_number))