import feign.Logger.Level; //导入依赖的package包/类
@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][]{
      {Level.NONE, Arrays.asList()},
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://robofu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: robofu.abc \\([0-9]+ms\\)")},
      {Level.HEADERS, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://robofu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: robofu.abc \\([0-9]+ms\\)")},
      {Level.FULL, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://robofu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] ",
          "\\[SendsStuff#login\\] \\{\"customer_name\": \"netflix\", \"user_name\": \"denominator\", \"password\": \"password\"\\}",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: robofu.abc \\([0-9]+ms\\)",
          "\\[SendsStuff#login\\] java.net.UnknownHostException: robofu.abc.*",
          "\\[SendsStuff#login\\] <--- END ERROR")}
  });
}
 

import feign.Logger.Level; //导入依赖的package包/类
/**
 * This is were the "magic" happens: it creates a Feign, which is a proxy interface for remote calling a REST endpoint with
 * Hystrix fallback support.
 *
 * @return The feign pointing to the service URL and with Hystrix fallback.
 */
private NamasteService getNextService() {
    final String serviceName = "namaste";
    // This stores the Original/Parent ServerSpan from ZiPkin.
    final ServerSpan serverSpan = brave.serverSpanThreadBinder().getCurrentServerSpan();
    final CloseableHttpClient httpclient =
        HttpClients.custom()
            .addInterceptorFirst(new BraveHttpRequestInterceptor(brave.clientRequestInterceptor(), new DefaultSpanNameProvider()))
            .addInterceptorFirst(new BraveHttpResponseInterceptor(brave.clientResponseInterceptor()))
            .build();
    String url = String.format("http://%s:8080/", serviceName);
    return HystrixFeign.builder()
        // Use apache HttpClient which contains the ZipKin Interceptors
        .client(new ApacheHttpClient(httpclient))
        // Bind Zipkin Server Span to Feign Thread
        .requestInterceptor((t) -> brave.serverSpanThreadBinder().setCurrentSpan(serverSpan))
        .logger(new Logger.ErrorLogger()).logLevel(Level.BASIC)
        .decoder(new JacksonDecoder())
        .target(NamasteService.class, url,
            () -> Collections.singletonList("Namaste response (fallback)"));
}
 

import feign.Logger.Level; //导入依赖的package包/类
/**
 * Generate a new Marathon client.
 * 
 * @param marathonProperties
 *          the properties containing the client information
 * @return the new client
 */
@Override
public Marathon build(MarathonProperties marathonProperties) {
  LOG.info("Generating Marathon client with parameters: {}", marathonProperties);

  return Feign
      .builder()
      .encoder(new GsonEncoder(ModelUtils.GSON))
      .decoder(new GsonDecoder(ModelUtils.GSON))
      .logger(new Slf4jLogger(Marathon.class))
      .logLevel(Level.FULL)
      .errorDecoder(new DeserializingMarathonErrorDecoder())
      .requestInterceptor(new BasicAuthRequestInterceptor(
          marathonProperties.getUsername(), marathonProperties.getPassword()))
      .requestInterceptor(template -> {
        template.header(HttpHeaders.ACCEPT, "application/json");
        template.header(HttpHeaders.CONTENT_TYPE, "application/json");
      })
      .target(Marathon.class, marathonProperties.getUrl().toString());
}
 

import feign.Logger.Level; //导入依赖的package包/类
private static OneSignalComms oneSignal() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    objectMapper.setSerializationInclusion(Include.NON_EMPTY);
    JacksonDecoder decoder = new JacksonDecoder(objectMapper);
    return Feign.builder()
            .encoder(new JacksonEncoder(objectMapper))
            .decoder(decoder)
            .decode404()
            .errorDecoder(new OneSignalErrorDecoder(decoder))
            .logger(new Slf4jLogger())
            .logLevel(Level.FULL)
            .target(OneSignalComms.class, "https://onesignal.com/api/v1");
}
 

import feign.Logger.Level; //导入依赖的package包/类
@Test
public void catalogClient() {

  CatalogClient mytest = Feign.builder().decoder(new JacksonDecoder()).logger(new Slf4jLogger())
      .logLevel(Level.FULL).target(CatalogClient.class, "http://localhost:8500");
  mytest.getServiceNodes("consul-starter-tester");
}
 

import feign.Logger.Level; //导入依赖的package包/类
/**
 * @param token   a unique bot's authentication token
 * @param logFile path to log file
 */
public TelegramService (String token, String logFile) {
    api = Feign.builder()
            .encoder(new JacksonEncoder())
            .decoder(new JacksonDecoder())
            .logger(new Logger.JavaLogger().appendToFile(logFile))
            .logLevel(Level.FULL)
            .target(TelegramApi.class, URL + token);
}
 

import feign.Logger.Level; //导入依赖的package包/类
/**
 * Returns a log configuration module or null if none is needed.
 */
static Object logModule(boolean quiet, boolean verbose) {
  checkArgument(!(quiet && verbose), "quiet and verbose flags cannot be used at the same time!");
  Logger.Level logLevel;
  if (quiet) {
    return null;
  } else if (verbose) {
    logLevel = Logger.Level.FULL;
  } else {
    logLevel = Logger.Level.BASIC;
  }
  return new LogModule(logLevel);
}
 

import feign.Logger.Level; //导入依赖的package包/类
public LogLevelEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

import feign.Logger.Level; //导入依赖的package包/类
public ReasonPhraseOptional(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

import feign.Logger.Level; //导入依赖的package包/类
public ReadTimeoutEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

import feign.Logger.Level; //导入依赖的package包/类
public UnknownHostEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

import feign.Logger.Level; //导入依赖的package包/类
public RetryEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

import feign.Logger.Level; //导入依赖的package包/类
LogModule(Level logLevel) {
  this.logLevel = logLevel;
}
 

import feign.Logger.Level; //导入依赖的package包/类
@Provides
@Singleton
Logger.Level level() {
  return logLevel;
}