Example usage for io.vertx.core.logging Logger error

Introduction

In this page you can find the example usage for io.vertx.core.logging Logger error.

Prototype

@Deprecated
public void error(final Object message, final Object... objects) 

Source Link

Usage

From source file:de.fraunhofer.fokus.redistest.DoInterestingThings.java

License:Creative Commons License

public void doIt(final Vertx vertx, final JsonObject redisConfig, String uuid, Logger logger,
        Handler<AsyncResult<JsonArray>> handler) {
    String zSetName = String.format(ZSET_NAME_FORMAT, uuid);
    final RangeLimitOptions rangeLimitOptions = (RangeLimitOptions) new RangeLimitOptions().setLimit(0,
            Constants.MAX_SEARCH_RESULTS);

    /*//from   w  w  w .  java 2  s. c  o m
     * To prevent errors in streams due to empty result set and to enable subscription
     * a dummy element will be prepended to the result set and removed in the subscription
     */
    final List<JsonArray> secureResultList = new ArrayList<JsonArray>();
    secureResultList.add(new JsonArray().add("default"));

    Single.using(DisposableRedisConnection::new, f -> f.create(vertx, redisConfig, logger), f -> f.dispose())
            .subscribe(redisClient -> {
                // emulate searech time in database
                //               vertx.setTimer(40,  xx->{
                Observable.range(1, 40)
                        .map(x -> new JsonObject().put(Constants.KEY_TYPE, Constants.KEY_DICE_OBJECT)
                                .put(Constants.KEY_RECORD_ID, String.valueOf(x))
                                .put(Constants.KEY_DICE_VALUE, x * 0.1).put(Constants.KEY_FAMILYNAME, x * 0.1)
                                .put(Constants.KEY_FIRSTNAME, 1))
                        .filter(x -> x != null) //remove results where comparison has been stopped due to bad dice values
                        // side effect - store objects in redis   
                        .subscribe(res -> {
                            String handle = res.getString(Constants.KEY_RECORD_ID);
                            String hashName = String.format(HASH_NAME_FORMAT, handle);
                            Single.zip(
                                    redisClient.rxZadd(zSetName, res.getDouble(Constants.KEY_DICE_VALUE),
                                            handle),
                                    redisClient.rxExpire(hashName, Constants.EXPIRE_AFTER),
                                    redisClient.rxHmset(hashName, res), (a, b, c) -> {
                                        return res;
                                    }).subscribe(r -> {
                                        // do nothing
                                    }, t -> handler.handle(Future.failedFuture(t)));
                        }, t -> handler.handle(Future.failedFuture(t)), () -> { //set expiration and retrieve record_ids
                            Observable
                                    .zip(redisClient.rxExpire(zSetName, Constants.EXPIRE_AFTER).toObservable(), // set expiration
                                            redisClient
                                                    .rxZrevrangebyscore(zSetName, "1", "0", rangeLimitOptions)
                                                    .toObservable(), // list of record_ids as JsonArray
                                            (a, b) -> Observable.from(b))
                                    .flatMap(x -> x)
                                    .map(handle -> redisClient
                                            .rxHgetall(String.format(HASH_NAME_FORMAT, handle)).toObservable()) // retrieve hash from redis
                                    .flatMap(x -> x).map(json -> toEntry(json))
                                    .collect(() -> new JsonArray(), (eList, e) -> eList.add(e))
                                    .subscribe(collectedJson -> handler
                                            .handle(Future.succeededFuture(collectedJson)), t -> {
                                                System.out.println("XXXX: " + t);
                                                logger.error("XXX", t);
                                                handler.handle(Future.failedFuture(t));
                                            });
                            //                        });
                        });
            }, t -> {
                CharArrayWriter cw = new CharArrayWriter();
                PrintWriter w = new PrintWriter(cw);
                t.printStackTrace(w);
                w.close();
                logger.error("trace", cw.toString());
                logger.error("YYY", t);
                handler.handle(Future.failedFuture(t));
            });

}

---

From source file:examples.CoreExamples.java

License:Open Source License

public void example18(String className, Exception exception) {

    // Note -these classes are Java only

    // You would normally maintain one static instance of Logger per Java class:

    Logger logger = LoggerFactory.getLogger(className);

    logger.info("something happened");
    logger.error("oops!", exception);
}

---

From source file:io.flowly.core.verticles.VerticleUtils.java

License:Open Source License

private static <T> void registerHandlers(EventBus eventBus, Logger logger,
        Queue<ConsumerRegistration<T>> registrations, Future<Void> future) {
    ConsumerRegistration<T> registration = registrations.remove();
    if (registration.isLocalOnly()) {
        eventBus.localConsumer(registration.getAddress(), registration.getMessageHandler());
        recursivelyRegisterHandlers(eventBus, logger, registrations, future);
    } else {//from w w w . j a va  2  s  .c  o  m
        eventBus.consumer(registration.getAddress(), registration.getMessageHandler())
                .completionHandler(result -> {
                    if (result.succeeded()) {
                        recursivelyRegisterHandlers(eventBus, logger, registrations, future);
                    } else {
                        Failure failure = new Failure(100,
                                "Failed to register handler: " + registration.getAddress(), result.cause());
                        logger.error(failure.getError(), failure.getCause());
                        future.fail(failure);
                    }
                });
    }
}

---