获取CDN域名访问日志的下载链接，具体下载操作请自行根据链接下载
参考文档：<a href="http://developer.qiniu.com/fusion/api/download-the-log">日志下载</a>

@param domains 待获取日志下载信息的域名列表
@param logDate 待获取日志的具体日期，格式为：2017-02-18
@return 获取日志下载链接的回复
491390
public CdnResult.LogListResult getCdnLogList(String[] domains, String logDate) throws QiniuException {
        HashMap<String, String> req = new HashMap<>();
        req.put("domains", StringUtils.join(domains, ";"));
        req.put("day", logDate);

        byte[] body = Json.encode(req).getBytes(Constants.UTF_8);
        String url = server + "/v2/tune/log/list";
        StringMap headers = auth.authorizationV2(url, "POST", body, Client.JsonMime);
        Response response = client.post(url, body, headers, Client.JsonMime);
        return response.jsonToObject(CdnResult.LogListResult.class);
    }
833340
public GetDomainLogResponse getDomainLog(GetDomainLogRequest request) {
        InternalRequest internalRequest = this.createRequest(request, HttpMethodName.GET, LOG, request.getDomain(), "log");
        if (request.getStartTime() != null) {
            internalRequest.addParameter("startTime", DateUtils.formatAlternateIso8601Date(request.getStartTime()));
        }
        if (request.getEndTime() != null) {
            internalRequest.addParameter("endTime", DateUtils.formatAlternateIso8601Date(request.getEndTime()));
        }
        return this.invokeHttpClient(internalRequest, GetDomainLogResponse.class);
    }
358378
public static XMLGregorianCalendar convertDate(Date date) {
        if (date == null) {
            return null;
        }

        GregorianCalendar gc = new GregorianCalendar();
        gc.setTimeInMillis(date.getTime());

        try {
            return getDatatypeFactory().newXMLGregorianCalendar(gc);
        } catch (DatatypeConfigurationException ex) {
            return null;
        }
    }
1289719
@Override
  public final synchronized ILog lazyGetLogger() throws Exception {
    String beanName = getLoggerName();
    ILog log = (ILog) getBeansMap().get(beanName);
    if (log == null) {
      LogFile logger = new LogFile();
      log = logger;
      String fileBaseName = "beige-accounting";
      logger.setMaxSize(10000000);
      logger.setPath(getWebAppPath() + File.separator + fileBaseName);
      String logPropFn = "/" + fileBaseName + ".properties";
      URL urlSetting = AFactoryAppBeansJdbc.class.getResource(logPropFn);
      if (urlSetting != null) {
        InputStream inputStream = null;
        try {
          Properties props = new Properties();
          inputStream = AFactoryAppBeansJdbc.class
            .getResourceAsStream(logPropFn);
          props.load(inputStream);
          String maxSizeStr = props.getProperty("maxSize");
          if (maxSizeStr != null) {
            Integer maxSize = Integer.parseInt(maxSizeStr);
            logger.setMaxSize(maxSize);
          }
          String maxIdleTmStr = props.getProperty("maxIdleTm");
          if (maxIdleTmStr != null) {
            Integer maxIdleTm = Integer.parseInt(maxIdleTmStr);
            logger.setMaxIdleTm(maxIdleTm);
          }
          String clsImmStr = props
            .getProperty("clsImm");
          if (clsImmStr != null) {
            Boolean clsImm = Boolean
              .valueOf(clsImmStr);
            logger.setClsImm(clsImm);
          }
        } catch (Exception ex) {
          ex.printStackTrace();
        } finally {
          if (inputStream != null) {
            try {
              inputStream.close();
            } catch (Exception ex) {
              ex.printStackTrace();
            }
          }
        }
      }
      logger.setDbgSh(getIsShowDebugMessages());
      getBeansMap().put(beanName, logger);
      logger.info(null, AFactoryAppBeansJdbc.class, beanName
        + " has been created.");
    }
    return log;
  }
571430
function logtime() {
  var d = new Date()
    , space = ' '
    , delimiter = ':'
    , str = d.toString()
    , month = str.split(' ')[1];
  return d.getDate()
    + space + month + space
    + d.getHours() + delimiter
    + pad(d.getMinutes()) + delimiter
    + pad(d.getSeconds())
    + '.'
    + pad(d.getMilliseconds(), 3);
}
370449
public ProxyDataSourceBuilder logQueryByCommons(CommonsLogLevel logLevel, String commonsLoggerName) {
        this.createCommonsQueryListener = true;
        this.commonsLogLevel = logLevel;
        this.commonsLoggerName = commonsLoggerName;
        return this;
    }
576167
public OvhUnpackTerms packName_subServices_domain_keepServiceTerms_GET(String packName, String domain) throws IOException {
		String qPath = "/pack/xdsl/{packName}/subServices/{domain}/keepServiceTerms";
		StringBuilder sb = path(qPath, packName, domain);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhUnpackTerms.class);
	}
1161848
public ProxyDataSourceBuilder logSlowQueryBySlf4j(long thresholdTime, TimeUnit timeUnit, String loggerName) {
        return logSlowQueryBySlf4j(thresholdTime, timeUnit, null, loggerName);
    }
1039209
public static void d(com.couchbase.lite.LogDomain domain, String msg) {
        sendToLoggers(com.couchbase.lite.LogLevel.DEBUG, domain, msg);
    }
998134
def _get_zone(self, domain, domain_id):
        
        api = self.api[self.account]
        for request in api['zone']['GET']:
            url = (request.copy()).get('url', '/').replace('<id>', domain_id)
            params = request.get('params', {}).copy()
            for param in params:
                params[param] = params[param].replace('<id>', domain_id)
            response = self._get(url, query_params=params)
        dom = Provider._filter_dom(response.text, api['filter'])
        zone_file_filter = [{'name': 'textarea', 'attrs': {'name': api['zone']['file']}}]
        zone_file = Provider._filter_dom(dom, zone_file_filter).renderContents().decode('UTF-8')
        hidden = Provider._extract_hidden_data(dom)
        zone = {'data': dns.zone.from_text(zone_file, origin=domain, relativize=False),
                'hidden': hidden}
        LOGGER.info('Hetzner => Get zone for domain %s', domain)
        return zone
608188
function (logLevel, args) {
            const time = dateFormat(new Date(), 'dd/mm/yyyy, h:MM:ss.l tt');
            // Each logger can have its own name. If this is
            // not provided, it will default to Unknown.
            const loggerName = __private.name || Constants.LOG_UNKNOWN_APP_ID;
            return [ (logLevel.name.length === 4 ? ' ' : '') +
                getLogLabel(logLevel)('[' + logLevel.name + ']'), time, '-',
            loggerName.padEnd(Constants.LOG_APP_ID_WIDTH), ':'].concat(Object.values(args));
        }
495620
public static List<CallLogEntry> getAllLogsOfDuration(List<CallLogEntry> logs, int duration, boolean greaterthan) {
		List<CallLogEntry> list = new ArrayList<CallLogEntry>();
		for(CallLogEntry log : logs) {
			if(log.duration<duration ^ greaterthan) {
			    list.add(log);
			}
		}
		return list;
	}
659107
public synchronized void fetchAndStoreLogsFromDriver(SessionId sessionId, WebDriver driver)
    throws IOException {
    if (!perSessionDriverEntries.containsKey(sessionId)) {
      perSessionDriverEntries.put(sessionId, new HashMap<>());
    }
    Map<String, LogEntries> typeToEntriesMap = perSessionDriverEntries.get(sessionId);
    if (storeLogsOnSessionQuit) {
      typeToEntriesMap.put(LogType.SERVER, getSessionLog(sessionId));
      Set<String> logTypeSet = driver.manage().logs().getAvailableLogTypes();
      for (String logType : logTypeSet) {
        typeToEntriesMap.put(logType, driver.manage().logs().get(logType));
      }
    }
  }
379886
public String[] domainList(String bucket) throws QiniuException {
        String url = String.format("%s/v6/domain/list?tbl=%s", configuration.apiHost(), bucket);
        Response res = get(url);
        if (!res.isOK()) {
            throw new QiniuException(res);
        }
        String[] domains = res.jsonToObject(String[].class);
        res.close();
        return domains;
    }
832524
public GetDomainStatisticsResponse getDomainStatistics(String domain) {
        GetDomainStatisticsRequest request = new GetDomainStatisticsRequest();
        request.setDomain(domain);
        return getDomainStatistics(request);
    }
884404
public ServerInstanceLogRecordList getLogListForServerInstance(Date time) throws LogRepositoryException {
		logger.entering(thisClass, "getLogListForServerInstance", time);
		
		LogQueryBean query = new LogQueryBean();
		ServerInstanceLogRecordList result = getLogListForServerInstance(new RemoteInstanceDetails(query, time, new String[0]), null);
		
		logger.exiting(thisClass, "getLogListForServerInstance", result);
		return result;
	}
1188403
private String[] queryInternal(Domain domain) throws IOException {
        Record[] records = null;
        if (domain.hostsFirst) {
            String[] ret = hosts.query(domain.domain);
            if (ret != null && ret.length != 0) {
                return ret;
            }
        }
        synchronized (cache) {
            if (Network.isNetworkChanged()) {
                cache.clear();
                synchronized (resolvers) {
                    index = 0;
                }
            } else {
                records = cache.get(domain.domain);
                if (records != null && records.length != 0) {
                    if (!records[0].isExpired()) {
                        rotate(records);
                        return records2Ip(records);
                    } else {
                        records = null;
                    }
                }
            }
        }

        IOException lastE = null;
        int firstOk = index;
        for (int i = 0; i < resolvers.length; i++) {
            int pos = (firstOk + i) % resolvers.length;
            String ip = Network.getIp();
            try {
                records = resolvers[pos].resolve(domain);
            } catch (DomainNotOwn e) {
                continue;
            } catch (IOException e) {
                lastE = e;
                e.printStackTrace();
            } catch (Exception e) {
                lastE = new IOException(e);
                e.printStackTrace();
            }
            String ip2 = Network.getIp();
            if ((records == null || records.length == 0) && ip.equals(ip2)) {
                synchronized (resolvers) {
                    if (index == firstOk) {
                        index++;
                        if (index == resolvers.length) {
                            index = 0;
                        }
                    }
                }
            } else {
                break;
            }
        }

        if (records == null || records.length == 0) {
            if (!domain.hostsFirst) {
                String[] rs = hosts.query(domain.domain);
                if (rs != null && rs.length != 0) {
                    return rs;
                }
            }
            if (lastE != null) {
                throw lastE;
            }
            throw new UnknownHostException(domain.domain);
        }
        records = trimCname(records);
        if (records.length == 0) {
            throw new UnknownHostException("no A records");
        }
        synchronized (cache) {
            cache.put(domain.domain, records);
        }
        return records2Ip(records);
    }