feign.Logger.Level Java Examples

private AbstractSimulatedDevice createDdiDevice(final String id, final String tenant, final int pollDelaySec,
        final URL baseEndpoint, final String gatewayToken) {

    final ObjectMapper mapper = new ObjectMapper()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
            .registerModule(new Jackson2HalModule());

    final RootControllerResourceClient controllerResource = Feign.builder()
            .requestInterceptor(new GatewayTokenInterceptor(gatewayToken))
            .contract(new IgnoreMultipleConsumersProducersSpringMvcContract()).logLevel(Level.HEADERS)
            .decoder(new ResponseEntityDecoder(new JacksonDecoder(mapper))).encoder(new JacksonEncoder())
            .logger(new Slf4jLogger()).decode404()
            .target(RootControllerResourceClient.class, baseEndpoint.toString());

    return new DDISimulatedDevice(id, tenant, pollDelaySec, controllerResource, deviceUpdater, gatewayToken);
}
 

@Setup
public void setup() {

  server = HttpServer.newServer(SERVER_PORT)
      .start((request, response) -> null);
  client = new OkHttpClient();
  client.retryOnConnectionFailure();
  okFeign = Feign.builder()
      .client(new feign.okhttp.OkHttpClient(client))
      .logLevel(Level.NONE)
      .logger(new Logger.ErrorLogger())
      .retryer(new Retryer.Default())
      .target(FeignTestInterface.class, "http://localhost:" + SERVER_PORT);
  queryRequest = new Request.Builder()
      .url("http://localhost:" + SERVER_PORT + "/?Action=GetUser&Version=2010-05-08&limit=1")
      .build();
}
 

@Test
public void testRxJavaTarget() throws Exception {
  this.webServer.enqueue(new MockResponse().setBody("1.0"));
  this.webServer.enqueue(new MockResponse().setBody("{ \"username\": \"test\" }"));

  TestReactiveXService service = RxJavaFeign.builder()
      .encoder(new JacksonEncoder())
      .decoder(new JacksonDecoder())
      .logger(new ConsoleLogger())
      .logLevel(Level.FULL)
      .target(TestReactiveXService.class, this.getServerUrl());
  assertThat(service).isNotNull();

  StepVerifier.create(service.version())
      .expectNext("1.0")
      .expectComplete()
      .verify();
  assertThat(webServer.takeRequest().getPath()).isEqualToIgnoringCase("/version");

  /* test encoding and decoding */
  StepVerifier.create(service.user("test"))
      .assertNext(user -> assertThat(user).hasFieldOrPropertyWithValue("username", "test"))
      .expectComplete()
      .verify();
  assertThat(webServer.takeRequest().getPath()).isEqualToIgnoringCase("/users/test");
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.NONE, Collections.emptyList()},
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://sna%fu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: sna%fu.abc \\([0-9]+ms\\)")},
      {Level.HEADERS, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://sna%fu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: sna%fu.abc \\([0-9]+ms\\)")},
      {Level.FULL, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://sna%fu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ",
          "\\[SendsStuff#login\\] \\{\"customer_name\": \"netflix\", \"user_name\": \"denominator\", \"password\": \"password\"\\}",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: sna%fu.abc \\([0-9]+ms\\)",
          "(?s)\\[SendsStuff#login\\] java.net.UnknownHostException: sna%fu.abc.*",
          "\\[SendsStuff#login\\] <--- END ERROR")}
  });
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.NONE, Collections.emptyList()},
      {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-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[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-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[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\\)",
          "(?s)\\[SendsStuff#login\\] java.net.UnknownHostException: robofu.abc.*",
          "\\[SendsStuff#login\\] <--- END ERROR")}
  });
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.NONE, Collections.emptyList()},
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- ERROR SocketTimeoutException: Read timed out \\([0-9]+ms\\)")},
      {Level.HEADERS, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR SocketTimeoutException: Read timed out \\([0-9]+ms\\)")},
      {Level.FULL, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ",
          "\\[SendsStuff#login\\] \\{\"customer_name\": \"netflix\", \"user_name\": \"denominator\", \"password\": \"password\"\\}",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- ERROR SocketTimeoutException: Read timed out \\([0-9]+ms\\)",
          "(?s)\\[SendsStuff#login\\] java.net.SocketTimeoutException: Read timed out.*",
          "\\[SendsStuff#login\\] <--- END ERROR")}
  });
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- HTTP/1.1 200 \\([0-9]+ms\\)")},
  });
}
 

/**
 * 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);
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.NONE, Collections.emptyList()},
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://robofu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: robofu.abc \\([0-9]+ms\\)",
          "\\[SendsStuff#login\\] ---> RETRYING",
          "\\[SendsStuff#login\\] ---> POST http://robofu.abc/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- ERROR UnknownHostException: robofu.abc \\([0-9]+ms\\)")}
  });
}
 

private static OneSignalComms oneSignal() {
    JacksonDecoder decoder = new JacksonDecoder(OBJECT_MAPPER);
    return Feign.builder()
            .encoder(new JacksonEncoder(OBJECT_MAPPER))
            .decoder(decoder)
            .decode404()
            .errorDecoder(new OneSignalErrorDecoder(decoder))
            .logger(new Slf4jLogger())
            .logLevel(Level.FULL)
            .target(OneSignalComms.class, "https://onesignal.com/api/v1");
}
 

@Parameters
public static Iterable<Object[]> data() {
  return Arrays.asList(new Object[][] {
      {Level.NONE, Collections.emptyList()},
      {Level.BASIC, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] <--- HTTP/1.1 200 OK \\([0-9]+ms\\)")},
      {Level.HEADERS, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- HTTP/1.1 200 OK \\([0-9]+ms\\)",
          "\\[SendsStuff#login\\] content-length: 3",
          "\\[SendsStuff#login\\] <--- END HTTP \\(3-byte body\\)")},
      {Level.FULL, Arrays.asList(
          "\\[SendsStuff#login\\] ---> POST http://localhost:[0-9]+/ HTTP/1.1",
          "\\[SendsStuff#login\\] Content-Length: 80",
          "\\[SendsStuff#login\\] Content-Type: application/json",
          "\\[SendsStuff#login\\] ",
          "\\[SendsStuff#login\\] \\{\"customer_name\": \"netflix\", \"user_name\": \"denominator\", \"password\": \"password\"\\}",
          "\\[SendsStuff#login\\] ---> END HTTP \\(80-byte body\\)",
          "\\[SendsStuff#login\\] <--- HTTP/1.1 200 OK \\([0-9]+ms\\)",
          "\\[SendsStuff#login\\] content-length: 3",
          "\\[SendsStuff#login\\] ",
          "\\[SendsStuff#login\\] foo",
          "\\[SendsStuff#login\\] <--- END HTTP \\(3-byte body\\)")}
  });
}
 

AsyncResponseHandler(Level logLevel, Logger logger, Decoder decoder, ErrorDecoder errorDecoder,
    boolean decode404, boolean closeAfterDecode) {
  super();
  this.logLevel = logLevel;
  this.logger = logger;
  this.decoder = decoder;
  this.errorDecoder = errorDecoder;
  this.decode404 = decode404;
  this.closeAfterDecode = closeAfterDecode;
}
 

@Test
public void testReactorTargetFull() throws Exception {
  this.webServer.enqueue(new MockResponse().setBody("1.0"));
  this.webServer.enqueue(new MockResponse().setBody("{ \"username\": \"test\" }"));

  TestReactorService service = ReactorFeign.builder()
      .encoder(new JacksonEncoder())
      .decoder(new JacksonDecoder())
      .logger(new ConsoleLogger())
      .decode404()
      .options(new Options())
      .logLevel(Level.FULL)
      .target(TestReactorService.class, this.getServerUrl());
  assertThat(service).isNotNull();

  StepVerifier.create(service.version())
      .expectNext("1.0")
      .expectComplete()
      .verify();
  assertThat(webServer.takeRequest().getPath()).isEqualToIgnoringCase("/version");


  /* test encoding and decoding */
  StepVerifier.create(service.user("test"))
      .assertNext(user -> assertThat(user).hasFieldOrPropertyWithValue("username", "test"))
      .expectComplete()
      .verify();
  assertThat(webServer.takeRequest().getPath()).isEqualToIgnoringCase("/users/test");

}
 

private GameServerClient buildGameServerClient(String server) {
    return Feign.builder()
            .client(new OkHttpClient())
            .encoder(new JacksonEncoder())
            .decoder(new JacksonDecoder())
            .errorDecoder(new ClientErrorDecoder())
            .logger(new Slf4jLogger(GameServerClient.class))
            .logLevel(Level.BASIC)
            .requestInterceptor(new BasicAuthRequestInterceptor(gameProperties.getBasicAuthUser(),
                    Hash.md5(gameProperties.getBasicAuthPassword())))
            .target(GameServerClient.class, gameProperties.getSchema() + "://" + server);
}
 

public ReasonPhraseOptional(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

public ReadTimeoutEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

public LogLevelEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

public UnknownHostEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

public FormatCharacterTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

default Level enrich(Level level) {
  return level;
}
 

public RetryEmitsTest(Level logLevel, List<String> expectedMessages) {
  this.logLevel = logLevel;
  logger.expectMessages(expectedMessages);
}
 

LogModule(Level logLevel) {
  this.logLevel = logLevel;
}
 

@Provides
@Singleton
Logger.Level level() {
  return logLevel;
}