Gets the console log of the browser

        @type levels:
        @return: List of browser log entries
340783
def get_browser_log(self, levels=None):
        
        logs = self.driver.get_log('browser')
        self.browser_logs += logs
        if levels is not None:
            logs = [entry for entry in logs if entry.get(u'level') in levels]
        return logs
331486
def get_log(self, request, response):
        
        return {
            'method': request.method,
            'path': request.get_full_path(),
            'code': response.status_code,
            'time': time.time(),
        }
1237673
public function getLogs()
	{
		if (file_exists($this->logPath))
		{
			$log = Filesystem::read($this->logPath);
			$levels = array();
			$this->logs = explode("\n", $log);
		}
		else
		{
			return array();
		}

		return $this->logs;
	}
1095620
def get_levels():
        
        levels = ffi.new('cairo_ps_level_t const **')
        num_levels = ffi.new('int *')
        cairo.cairo_ps_get_levels(levels, num_levels)
        levels = levels[0]
        return [levels[i] for i in range(num_levels[0])]
965213
def get_logs(self, stdout=True, stderr=True, timestamps=False, tail='all',
                 since=None):
        
        return self.inner().logs(
            stdout=stdout, stderr=stderr, timestamps=timestamps, tail=tail,
            since=since)
256880
def show_logging(level=logging.INFO):
    
    logger = logging.getLogger()

    h = logging.StreamHandler(stream=sys.stderr)
    h.setFormatter(logging.Formatter(fmt="[%(levelname)-8s] %(name)s: %(message)s"))

    logger.addHandler(h)
    logger.setLevel(level)
708589
def list_logs(self, source, entry_id=None, start_time=None, end_time=None):
        
        route_values = {}
        if source is not None:
            route_values['source'] = self._serialize.url('source', source, 'str')
        if entry_id is not None:
            route_values['entryId'] = self._serialize.url('entry_id', entry_id, 'str')
        query_parameters = {}
        if start_time is not None:
            query_parameters['startTime'] = self._serialize.query('start_time', start_time, 'iso-8601')
        if end_time is not None:
            query_parameters['endTime'] = self._serialize.query('end_time', end_time, 'iso-8601')
        response = self._send(http_method='GET',
                              location_id='991842f3-eb16-4aea-ac81-81353ef2b75c',
                              version='5.0-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('[INotificationDiagnosticLog]', self._unwrap_collection(response))
7662
@SuppressWarnings("unchecked")
	private static Enumeration<LogEntry> getLogEntries(LogReaderService lrs)
	{
		return (Enumeration<LogEntry>)lrs.getLog();
	}
454783
def stream_logs(self, stdout=True, stderr=True, tail='all', timeout=10.0):
        
        return stream_logs(
            self.inner(), stdout=stdout, stderr=stderr, tail=tail,
            timeout=timeout)
524800
def get_basic_logger(level=logging.WARN, scope='reliure'):
    
    logger = logging.getLogger(scope)
    logger.setLevel(level)
    # create console handler with a higher log level
    ch = logging.StreamHandler()
    ch.setLevel(level)
    # create formatter and add it to the handlers
    formatter = ColorFormatter('%(asctime)s:%(levelname)s:%(name)s:%(message)s')
    ch.setFormatter(formatter)
    # add the handlers to the logger
    logger.addHandler(ch)   
    return logger
42017
def getStreamLevel(self):
        
        shlvl = 0
        for i in range(0,len(self.handlers)):
            h = self.handlers[i]
            if isinstance(h,logging.StreamHandler):
                shlvl = h.level
        return shlvl
353671
def get_level():
    
    handler, logger = find_handler(logging.getLogger(), match_stream_handler)
    return handler.level if handler else DEFAULT_LOG_LEVEL
171843
def levels(self):
        
        ret = [[] for i in range(self.height)]
        for node in self.subtree:
            ret[node.level - self.level].append(node)
        return ret
477963
def logs(self):
        """"""
        url = self._url + "/logs"
        return _log(url=url,
                    securityHandler=self._securityHandler,
                    proxy_url=self._proxy_url,
                    proxy_port=self._proxy_port)
1011724
def get_logs(self):
        

        build_logs = NamedTemporaryFile(prefix="buildstep-%s" % self.build_id,
                                        suffix=".log",
                                        mode='wb')
        build_logs.write("\n".join(self.workflow.build_result.logs).encode('utf-8'))
        build_logs.flush()
        filename = "{platform}-build.log".format(platform=self.platform)
        return [Output(file=build_logs,
                       metadata=self.get_output_metadata(build_logs.name,
                                                         filename))]
109958
def get_methods(self):
        
        return [
            ("levels", self.print_levels),
            ("make", self.make_report),
            ("clear", self.clear_report),
            ("show", self.show_report),
            ("write", self.write_report),
        ]
733810
function logFn(level){
    return function(msg){
      var args = Array.prototype.slice.call(arguments);

      if (level === 'hr'){
        args = ['------------------------------------------------------------'];
        args.push({_hr: true});
        level = 'debug';
      }

      var logFn = logger[level] || console[level].bind(console);
      if (enabled.enabled) logFn.apply(logger, args);
    };
  }