/** * @since 2.6.1 */ @Override public Message newMessage(final String message, final Object p0, final Object p1) { return new ParameterizedMessage(message, p0, p1); }
/** * Pushes new diagnostic context information for the current thread. * * <p> * The contents of the <code>message</code> and args parameters are determined solely by the client. The message * will be treated as a format String and tokens will be replaced with the String value of the arguments in * accordance with ParameterizedMessage. * </p> * * @param message The new diagnostic context information. * @param args Parameters for the message. */ public static void push(final String message, final Object... args) { contextStack.push(ParameterizedMessage.format(message, args)); }
@Test public void testNoArgs() { final String testMsg = "Test message {}"; ParameterizedMessage msg = new ParameterizedMessage(testMsg, (Object[]) null); String result = msg.getFormattedMessage(); assertEquals(testMsg, result); final Object[] array = null; msg = new ParameterizedMessage(testMsg, array, null); result = msg.getFormattedMessage(); assertEquals(testMsg, result); }
/** * Returns the formatted message. * @return the formatted message. */ @Override public String getFormattedMessage() { if (formattedMessage == null) { final StringBuilder buffer = getThreadLocalStringBuilder(); formatTo(buffer); formattedMessage = buffer.toString(); StringBuilders.trimToMaxSize(buffer, Constants.MAX_REUSABLE_MESSAGE_SIZE); } return formattedMessage; }
/** * Creates {@link SimpleMessage} instances containing the formatted parameterized message string. * * @param message The message pattern. * @param params The message parameters. * @return The Message. * * @see MessageFactory#newMessage(String, Object...) */ @Override public Message newMessage(final String message, final Object... params) { if (params == null) { return new SimpleMessage(message); } final ParameterizedMessage msg = new ParameterizedMessage(message, params); return new StatusMessage(msg.getFormattedMessage(), msg.getThrowable()); } }
logger.debug("processing [{}]: execute", summary); final ClusterState previousClusterState = state(); if (!previousClusterState.nodes().isLocalNodeElectedMaster() && taskInputs.runOnlyWhenMaster()) { logger.debug("failing [{}]: local node is no longer master", summary); taskInputs.onNoLongerMaster(); return; logger.debug("cluster state updated, version [{}], source [{}]", newClusterState.version(), summary); logger.debug("publishing cluster state version [{}]", newClusterState.version()); try { clusterStatePublisher.accept(clusterChangedEvent, taskOutputs.createAckListener(threadPool, newClusterState)); logger.warn(() -> new ParameterizedMessage( "failing [{}]: failed to commit cluster state version [{}]", summary, version), t); taskOutputs.publishingFailed(t); taskOutputs.clusterStatePublished(clusterChangedEvent); } catch (Exception e) { logger.error(() -> new ParameterizedMessage( "exception thrown while notifying executor of new cluster state publication [{}]", summary), e); logger.warn(() -> new ParameterizedMessage( "failed to publish updated cluster state in [{}]:\nversion [{}], uuid [{}], source [{}]\n{}", executionTime,
private void allNodesResponded() { if (activeCopies.get() != expectedActiveCopies) { logger.trace("not deleting shard {}, expected {} active copies, but only {} found active copies", shardId, expectedActiveCopies, activeCopies.get()); return; } ClusterState latestClusterState = clusterService.state(); if (clusterStateVersion != latestClusterState.getVersion()) { logger.trace("not deleting shard {}, the latest cluster state version[{}] is not equal to cluster state " + "before shard active api call [{}]", shardId, latestClusterState.getVersion(), clusterStateVersion); return; } clusterService.getClusterApplierService().runOnApplierThread("indices_store ([" + shardId + "] active fully on other nodes)", currentState -> { if (clusterStateVersion != currentState.getVersion()) { logger.trace("not deleting shard {}, the update task state version[{}] is not equal to cluster state before " + "shard active api call [{}]", shardId, currentState.getVersion(), clusterStateVersion); return; } try { indicesService.deleteShardStore("no longer used", shardId, currentState); } catch (Exception ex) { logger.debug(() -> new ParameterizedMessage("{} failed to delete unallocated shard, ignoring", shardId), ex); } }, (source, e) -> logger.error(() -> new ParameterizedMessage("{} unexpected error during deletion of unallocated shard", shardId), e) ); }
@Override public void onFailure(Exception t) { logger.debug(() -> new ParameterizedMessage("failed to close indices [{}]", (Object) concreteIndices), t); listener.onFailure(t); } });
log.info("initial message"); Thread.sleep(500); final Message msg = new ParameterizedMessage("{}", map); Log4jLogEvent event = Log4jLogEvent.newBuilder() .setLevel(Level.WARN)
private void closeShard(String reason, ShardId sId, IndexShard indexShard, Store store, IndexEventListener listener) { final int shardId = sId.id(); final Settings indexSettings = this.getIndexSettings().getSettings(); try { indexShard.close(reason, flushEngine); } catch (Exception e) { logger.debug(() -> new ParameterizedMessage("[{}] failed to close index shard", shardId), e); store.close(); } else { logger.trace("[{}] store not initialized prior to closing shard, nothing to close", shardId); logger.warn( () -> new ParameterizedMessage( "[{}] failed to close store on shard removal (reason: [{}])", shardId, reason), e);
public void performStateRecovery(final GatewayStateRecoveredListener listener) throws GatewayException { String[] nodesIds = clusterService.state().nodes().getMasterNodes().keys().toArray(String.class); logger.trace("performing state recovery from {}", Arrays.toString(nodesIds)); TransportNodesListGatewayMetaState.NodesGatewayMetaState nodesState = listGatewayMetaState.list(nodesIds, null).actionGet(); logger.warn("failed to fetch state from node", failedNodeException); logger.debug("[{}] found [{}], required [{}], not adding", index, indexMetaDataCount, requiredAllocation); logger.warn(() -> new ParameterizedMessage("recovering index {} failed - recovering as closed", electedIndex), e); electedIndexMetaData = IndexMetaData.builder(electedIndexMetaData).state(IndexMetaData.State.CLOSE).build();
@Override protected void innerOnFailure(Exception e) { logger.warn(() -> new ParameterizedMessage("send message failed [channel: {}]", channel), e); delegateListener.onFailure(e); } }
assert newClusterState.nodes().getMasterNode() != null : "received a cluster state without a master"; assert !newClusterState.blocks().hasGlobalBlock(discoverySettings.getNoMasterBlock()) : "received a cluster state with a master block"; if (currentState.nodes().isLocalNodeElectedMaster() && newClusterState.nodes().isLocalNodeElectedMaster() == false) { handleAnotherMaster(currentState, newClusterState.nodes().getMasterNode(), newClusterState.version(), "via a new cluster state"); } catch (Exception inner) { inner.addSuppressed(e); logger.error(() -> new ParameterizedMessage("unexpected exception while failing [{}]", reason), inner); if (currentState.blocks().hasGlobalBlock(discoverySettings.getNoMasterBlock())) { logger.debug("got first state from fresh master [{}]", newClusterState.nodes().getMasterNodeId());
@Override public void onShardInactive(IndexShard indexShard) { for (IndexEventListener listener : listeners) { try { listener.onShardInactive(indexShard); } catch (Exception e) { logger.warn(() -> new ParameterizedMessage("[{}] failed to invoke on shard inactive callback", indexShard.shardId().getId()), e); throw e; } } }
@Override public ClusterState execute(ClusterState currentState) { if (currentState.blocks().disableStatePersistence()) { return currentState; MetaData.Builder metaData = MetaData.builder(currentState.metaData()); ClusterBlocks.Builder blocks = ClusterBlocks.builder().blocks(currentState.blocks()); RoutingTable.Builder routingTableBuilder = RoutingTable.builder(currentState.routingTable()); final Version minIndexCompatibilityVersion = currentState.getNodes().getMaxNodeVersion() .minimumIndexCompatibilityVersion(); boolean importNeeded = false; for (IndexMetaData indexMetaData : request.indices) { if (indexMetaData.getCreationVersion().before(minIndexCompatibilityVersion)) { logger.warn("ignoring dangled index [{}] on node [{}]" + " since it's created version [{}] is not supported by at least one node in the cluster minVersion [{}]", indexMetaData.getIndex(), request.fromNode, indexMetaData.getCreationVersion(), if (currentState.metaData().hasAlias(indexMetaData.getIndex().getName())) { logger.warn("ignoring dangled index [{}] on node [{}] due to an existing alias with the same name", indexMetaData.getIndex(), request.fromNode); continue; } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("found dangled index [{}] on node [{}]. This index cannot be " + "upgraded to the latest version, adding as closed", indexMetaData.getIndex(), request.fromNode), ex); upgradedIndexMetaData = IndexMetaData.builder(indexMetaData).state(IndexMetaData.State.CLOSE)
DiscoveryNodes nodes = response.getState().nodes(); Iterable<DiscoveryNode> nodesIter = nodes.getNodes()::valuesIt; for (DiscoveryNode n : nodesIter) { DiscoveryNode node = maybeAddProxyAddress(proxyAddress, n); logger.debug(() -> new ParameterizedMessage("failed to connect to node {}", node), ex); listener.onResponse(null); } catch (CancellableThreads.ExecutionCancelledException ex) { listener.onFailure(ex); // we got canceled - fail the listener and step out } catch (Exception ex) { logger.warn(() -> new ParameterizedMessage("fetching nodes from external cluster {} failed", clusterAlias), ex); collectRemoteNodes(seedNodes, transportService, connectionManager, listener);
@Override public void publish(ClusterChangedEvent clusterChangedEvent, AckListener ackListener) { ClusterState newState = clusterChangedEvent.state(); assert newState.getNodes().isLocalNodeElectedMaster() : "Shouldn't publish state when not master " + clusterChangedEvent.source(); } catch (FailedToCommitClusterStateException t) { logger.debug("failed to publish cluster state version [{}] (not enough nodes acknowledged, min master nodes [{}])", newState.version(), electMaster.minimumMasterNodes()); final DiscoveryNode localNode = newState.getNodes().getLocalNode(); final CountDownLatch latch = new CountDownLatch(1); final AtomicBoolean processedOrFailed = new AtomicBoolean(); boolean sentToApplier = processNextCommittedClusterState("master " + newState.nodes().getMasterNode() + " committed version [" + newState.version() + "] source [" + clusterChangedEvent.source() + "]"); if (sentToApplier == false && processedOrFailed.get() == false) { assert false : "cluster state published locally neither processed nor failed: " + newState; logger.warn("cluster state with version [{}] that is published locally has neither been processed nor failed", newState.version()); return; latch.await(); } catch (InterruptedException e) { logger.debug(() -> new ParameterizedMessage( "interrupted while applying cluster state locally [{}]", clusterChangedEvent.source()), e); Thread.currentThread().interrupt();
@Override public void beforeIndexShardDeleted(ShardId shardId, Settings indexSettings) { for (IndexEventListener listener : listeners) { try { listener.beforeIndexShardDeleted(shardId, indexSettings); } catch (Exception e) { logger.warn(() -> new ParameterizedMessage("[{}] failed to invoke before shard deleted callback", shardId.getId()), e); throw e; } } }
@Override public void error(Throwable error, String message, Object... args) { if (logger.isErrorEnabled()) { String formatted = ParameterizedMessage.format(message, args); logger.error(formatted, error); } } }
@Override public TerminationHandle warmReader(final IndexShard indexShard, final Engine.Searcher searcher) { final MapperService mapperService = indexShard.mapperService(); final Map<String, MappedFieldType> warmUpGlobalOrdinals = new HashMap<>(); if (indexShard.warmerService().logger().isTraceEnabled()) { indexShard.warmerService().logger().trace( "warmed global ordinals for [{}], took [{}]", fieldType.name(), .warmerService() .logger() .warn(() -> new ParameterizedMessage("failed to warm-up global ordinals for [{}]", fieldType.name()), e); } finally { latch.countDown();