public void updateFailed(Throwable exception) { // We depend on pending calls to request another metadata update this.state = State.QUIESCENT; if (exception instanceof AuthenticationException) { log.warn("Metadata update failed due to authentication error", exception); this.authException = (AuthenticationException) exception; } else { log.info("Metadata update failed", exception); } }
public void printMissingClasses() { int count = missingClasses.size(); if (count == 0) { return; } LOG.warn("Found {} references to unknown classes", count); if (LOG.isDebugEnabled()) { List<String> clsNames = new ArrayList<>(missingClasses); Collections.sort(clsNames); for (String cls : clsNames) { LOG.debug(" {}", cls); } } } }
public void updateStatefulBolt(int taskId, TransactionState state) { Map<Integer, TransactionState> statefulBoltStates = statefulBolts.get(taskToComponentId.get(taskId)); if (statefulBoltStates.put(taskId, state) != null) { LOG.warn("Duplicated state commit for statefulBolt-{}, state={}", taskId, state); } else { receivedStatefulBoltCount++; } }
/** * * @param rule * @param applyOrder RoutingRule are applied in order, latter rules can override previous rules */ public static void registerRule(RoutingRule rule, int applyOrder) { if (applyOrder > rules.size()) { logger.warn("apply order " + applyOrder + " is larger than rules size " + rules.size() + ", will put the new rule at the end"); rules.add(rule); } rules.add(applyOrder, rule); }
private List<AwsEndpoint> getClusterEndpointsFromConfig() { String[] availZones = clientConfig.getAvailabilityZones(clientConfig.getRegion()); String myZone = InstanceInfo.getZone(availZones, myInstanceInfo); Map<String, List<String>> serviceUrls = EndpointUtils .getServiceUrlsMapFromConfig(clientConfig, myZone, clientConfig.shouldPreferSameZoneEureka()); List<AwsEndpoint> endpoints = new ArrayList<>(); for (String zone : serviceUrls.keySet()) { for (String url : serviceUrls.get(zone)) { try { endpoints.add(new AwsEndpoint(url, getRegion(), zone)); } catch (Exception ignore) { logger.warn("Invalid eureka server URI: {}; removing from the server pool", url); } } } logger.debug("Config resolved to {}", endpoints); if (endpoints.isEmpty()) { logger.error("Cannot resolve to any endpoints from provided configuration: {}", serviceUrls); } return endpoints; }
private boolean emitRecord (SpoutOutputCollector collector, Record record, KinesisMessageId kinesisMessageId) { boolean result = false; List<Object> tuple = kinesisConfig.getRecordToTupleMapper().getTuple(record); // if a record is returned put the sequence number in the emittedPerShard to tie back with ack or fail if (tuple != null && tuple.size() > 0) { collector.emit(tuple, kinesisMessageId); if (!emittedPerShard.containsKey(kinesisMessageId.getShardId())) { emittedPerShard.put(kinesisMessageId.getShardId(), new TreeSet<BigInteger>()); } emittedPerShard.get(kinesisMessageId.getShardId()).add(new BigInteger(record.getSequenceNumber())); result = true; } else { // ack to not process the record again on restart and move on to next message LOG.warn("Record " + record + " did not return a tuple to emit. Hence acking it"); ack(kinesisMessageId); } return result; }
@Override public void log (int level, String category, String message, Throwable ex) { final String logString = "[KRYO " + category + "] " + message; switch (level) { case Log.LEVEL_ERROR: log.error(logString, ex); break; case Log.LEVEL_WARN: log.warn(logString, ex); break; case Log.LEVEL_INFO: log.info(logString, ex); break; case Log.LEVEL_DEBUG: log.debug(logString, ex); break; case Log.LEVEL_TRACE: log.trace(logString, ex); break; } } }
public void setMessage(String id, Map<String, Object> message) { Map<String, Object> tmp = Maps.newHashMap(); tmp.putAll(message); tmp.put(Message.FIELD_ID, id); if (tmp.containsKey(Message.FIELD_TIMESTAMP)) { final Object tsField = tmp.get(Message.FIELD_TIMESTAMP); try { tmp.put(Message.FIELD_TIMESTAMP, ES_DATE_FORMAT_FORMATTER.parseDateTime(String.valueOf(tsField))); } catch (IllegalArgumentException e) { // could not parse date string, this is likely a bug, but we will leave the original value alone LOG.warn("Could not parse timestamp of message {}", message.get("id"), e); } } this.message = new Message(tmp); }
public List<HBMessage> sendAll(HBMessage m) throws PacemakerConnectionException, InterruptedException { List<HBMessage> responses = new ArrayList<HBMessage>(); LOG.debug("Using servers: {}", servers); for (String s : servers) { try { HBMessage response = getClientForServer(s).send(m); responses.add(response); } catch (PacemakerConnectionException e) { LOG.warn("Failed to connect to the pacemaker server {}, attempting to reconnect", s); getClientForServer(s).reconnect(); } } if (responses.size() == 0) { throw new PacemakerConnectionException("Failed to connect to any Pacemaker."); } return responses; }
if (argsTypes.size() != mthArgs.size()) { if (argsTypes.isEmpty()) { return false; LOG.warn("Wrong signature parse result: {} -> {}, not generic version: {}", sp, argsTypes, mthArgs); return false; } else if (getParentClass().getAccessFlags().isEnum()) { argsTypes.add(0, mthArgs.get(0)); argsTypes.add(1, mthArgs.get(1)); } else { argsTypes.add(0, mthArgs.get(0)); if (argsTypes.size() != mthArgs.size()) { return false; return true; } catch (JadxRuntimeException e) { LOG.error("Method signature parse error: {}", this, e); return false;
public void printReport() { if (getErrorCount() > 0) { LOG.error("{} errors occurred in following nodes:", getErrorCount()); List<String> errors = new ArrayList<>(errorNodes.size()); for (IAttributeNode node : errorNodes) { String nodeName = node.getClass().getSimpleName().replace("Node", ""); errors.add(nodeName + ": " + node); } Collections.sort(errors); for (String err : errors) { LOG.error(" {}", err); } } if (getWarnsCount() > 0) { LOG.warn("{} warnings in {} nodes", getWarnsCount(), warnNodes.size()); } } }
public void close() { closed = true; if (serverSocket != null) { try { serverSocket.close(); } catch (IOException e) { logger.error("Failed to close serverSocket", e); } finally { serverSocket = null; } } logger.info("closing this server"); synchronized (socketNodeList) { for (SocketNode sn : socketNodeList) { sn.close(); } } if (socketNodeList.size() != 0) { logger.warn("Was expecting a 0-sized socketNodeList after server shutdown"); } }
public static void interceptorsForHandler(AtmosphereFramework framework, List<Class<? extends AtmosphereInterceptor>> interceptors, List<AtmosphereInterceptor> l) { for (Class<? extends AtmosphereInterceptor> i : interceptors) { if (!framework.excludedInterceptors().contains(i.getName()) && (!AtmosphereFramework.DEFAULT_ATMOSPHERE_INTERCEPTORS.contains(i))) { try { logger.info("Adding {}", i); l.add(framework.newClassInstance(AtmosphereInterceptor.class, i)); } catch (Throwable e) { logger.warn("", e); } } } }
private List<Converter> loadConverters(Map<String, Map<String, Object>> requestConverters) { List<Converter> converters = Lists.newArrayList(); for (Map.Entry<String, Map<String, Object>> c : requestConverters.entrySet()) { try { converters.add(converterFactory.create(Converter.Type.valueOf(c.getKey().toUpperCase(Locale.ENGLISH)), c.getValue())); } catch (ConverterFactory.NoSuchConverterException e) { LOG.warn("No such converter [" + c.getKey() + "]. Skipping.", e); } catch (ConfigurationException e) { LOG.warn("Missing configuration for [" + c.getKey() + "]. Skipping.", e); } } return converters; }
@Override public synchronized void shutdown() { if (!canShutdown()) { LOG.debug("ZooKeeper server is not running, so not proceeding to shutdown!"); return; } LOG.info("Shutting down"); try { super.shutdown(); } catch (Exception e) { LOG.warn("Ignoring unexpected exception during shutdown", e); } try { if (syncProcessor != null) { syncProcessor.shutdown(); } } catch (Exception e) { LOG.warn("Ignoring unexpected exception in syncprocessor shutdown", e); } } }
protected boolean runImpl() { try { Message message = consumer.receive(); if (message == null) { LOG.debug("Message consumer was closed."); return true; } ObjectMessage omessage = (ObjectMessage) message; daemonThreadStatsCollector.captureStats(thread.getId()); listener.onMessage((GoMessage) omessage.getObject()); } catch (JMSException e) { LOG.warn("Error receiving message. Message receiving will continue despite this error.", e); } catch (Exception e) { LOG.error("Exception thrown in message handling by listener {}", listener, e); } finally { daemonThreadStatsCollector.clearStats(thread.getId()); } return false; }
@Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { if (cause instanceof ConnectException) { LOG.warn("Connection to pacemaker failed. Trying to reconnect {}", cause.getMessage()); } else { LOG.error("Exception occurred in Pacemaker.", cause); } client.reconnect(); } }