Get one log from the log queue.
6632
async def pop_log(self):
        """"""
        self._check_receive_loop()
        res = self.log_queue.get()
        self._check_error(res)
        return res
37971
def getLogger(name=None, filename=None, filemode=None, level=WARNING):
    
    warnings.warn("getLogger is deprecated, Use get_logger instead.",
                  DeprecationWarning, stacklevel=2)
    return get_logger(name, filename, filemode, level)
474375
def extract_log_level_from_environment(k, default):
    """"""
    return LOG_LEVELS.get(os.environ.get(k)) or int(os.environ.get(k, default))
1262720
def get_logger(name):
    """"""
    logger = logging.getLogger(name)
    logger.setLevel(getenv('LOGLEVEL', 'INFO'))
    return logger
505586
def job_get_log(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/getLog' % object_id, input_params, always_retry=always_retry, **kwargs)
392919
public LogEntry getLogEntry(long entryIndex) {
        if (entryIndex < 1) {
            throw new IllegalArgumentException("Illegal index: " + entryIndex + ". Index starts from 1.");
        }
        if (!containsLogEntry(entryIndex)) {
            return null;
        }

        LogEntry logEntry = logs.read(toSequence(entryIndex));
        assert logEntry.index() == entryIndex : "Expected: " + entryIndex + ", Entry: " + logEntry;
        return logEntry;
    }
513151
def get_event_log(self, object_id):
		""""""
		content = self._fetch("/event_log/%s" % object_id, method="GET")
		return FastlyEventLog(self, content)
1268289
def get_logs(self, log_stream_name, get_last=50):
        """"""
        response = self._log_client.get_log_events(
            logGroupName='/aws/batch/job',
            logStreamName=log_stream_name,
            startFromHead=False)
        events = response['events']
        return '\n'.join(e['message'] for e in events[-get_last:])
169009
def get_logger(name):
        """"""
        if name is None:
            return NoLogger()

        logger = logging.getLogger(name)
        if Logger.use_external_configuration:
            logger.propagate = False
        return logger
629789
public static TaskQueue getInstance( ILogger logger, String strQueueName )
  {
    if( strQueueName == null )
    {
      return null;
    }

    TaskQueue taskQueue = QUEUE_MAP.get( strQueueName );
    if( taskQueue == null )
    {
      taskQueue = new TaskQueue( logger, strQueueName );
      QUEUE_MAP.put( strQueueName, taskQueue );
    }

    return taskQueue;
  }
255993
def process_log_record(self, log_record):
        """"""
        log_record["version"] = __version__
        log_record["program"] = PROGRAM_NAME
        log_record["service_name"] = log_record.pop('threadName', None)
        # return jsonlogger.JsonFormatter.process_log_record(self, log_record)

        return log_record
639469
def log(self, *args):
        '''
        
        '''
        if len(args):
            self._log = args[0]
        else:
            return self._log
141362
public Log getLog(String name) {
		Log log = logCache.get(name);
		if (null == log) {
			log = createLog(name);
			logCache.put(name, log);
		}
		return log;
	}
637806
public Log getLog(Class<?> clazz) {
		Log log = logCache.get(clazz);
		if (null == log) {
			log = createLog(clazz);
			logCache.put(clazz, log);
		}
		return log;
	}
782871
def one(cls, path='', index=0):
        """"""
        url = urljoin(cls._meta.base_url, path)
        pq_items = cls._get_items(url=url, **cls._meta._pyquery_kwargs)
        item = pq_items.eq(index)
        if not item:
            raise ItemDoesNotExist("%s not found" % cls.__name__)
        return cls(item=item)
1083556
def slowlog_get(self, length=None):
        """"""
        if length is not None:
            if not isinstance(length, int):
                raise TypeError("length must be int or None")
            return self.execute(b'SLOWLOG', b'GET', length)
        else:
            return self.execute(b'SLOWLOG', b'GET')
1060240
def get_logger(name=None, level=logging.DEBUG, stream=None):
    """"""
    logger = logging.getLogger(name)
    colored = colorize_logger(logger, stream=stream, level=level)
    return colored