Refine search
/** * Add an event to the queue. It will be processed in the order received. * * @param event Event */ public void addEvent(Event event) { if(event == null) throw new IllegalStateException("event must be non-null"); if(logger.isTraceEnabled()) logger.trace("Adding event " + event); eventQueue.add(event); }
/** {@inheritDoc} */ @Override public void trace(String msg) { if (!impl.isTraceEnabled()) warning("Logging at TRACE level without checking if TRACE level is enabled: " + msg); impl.trace(msg); }
@Override public void execute(Pipeline pipeline) { for(Map.Entry<Node, Slop> slopToBeSent: slopsToBeSent.entrySet()) { Slop slop = slopToBeSent.getValue(); Node failedNode = slopToBeSent.getKey(); if(logger.isTraceEnabled()) logger.trace("Performing hinted handoff for node " + failedNode + ", store " + pipelineData.getStoreName() + "key " + key + ", version" + version); hintedHandoff.sendHintParallel(failedNode, version, slop); } pipeline.addEvent(completeEvent); } }
for(SelectionKey sk: selector.keys()) { try { if(logger.isTraceEnabled()) logger.trace("Closing SelectionKey's channel"); if(logger.isTraceEnabled()) logger.trace("Cancelling SelectionKey");
if(logger.isTraceEnabled()) logger.trace("Shut down SelectorManager thread pool acceptor, waiting " + SHUTDOWN_TIMEOUT_MS + " ms for termination");
int dataSize = inputStream.readInt(); if(logger.isTraceEnabled()) logger.trace("In isCompleteRequest, dataSize: " + dataSize + ", buffer position: " + buffer.position()); if(logger.isTraceEnabled()) logger.trace("In isCompleteRequest, probable partial read occurred: " + e);
@Override public Map<ByteArray, List<Versioned<byte[]>>> getAll(Iterable<ByteArray> keys, Map<ByteArray, byte[]> transforms) throws VoldemortException { StoreUtils.assertValidKeys(keys); Map<ByteArray, List<Versioned<byte[]>>> results = null; long startTimeNs = -1; if(logger.isTraceEnabled()) startTimeNs = System.nanoTime(); try { results = StoreUtils.getAll(this, keys, transforms); } catch(PersistenceFailureException pfe) { throw pfe; } finally { if(logger.isTraceEnabled()) { String keyStr = ""; for(ByteArray key: keys) keyStr += key + " "; logger.trace("Completed GETALL (" + getName() + ") from keys " + keyStr + " in " + (System.nanoTime() - startTimeNs) + " ns at " + System.currentTimeMillis()); } } return results; }
/** * Method to service public recording APIs * * @param op Operation being tracked * @param timeNS Duration of operation * @param numEmptyResponses Number of empty responses being sent back, * i.e.: requested keys for which there were no values (GET and GET_ALL only) * @param valueSize Size in bytes of the value * @param keySize Size in bytes of the key * @param getAllAggregateRequests Total of amount of keys requested in the operation (GET_ALL only) */ private void recordTime(Tracked op, long timeNS, long numEmptyResponses, long valueSize, long keySize, long getAllAggregateRequests) { counters.get(op).addRequest(timeNS, numEmptyResponses, valueSize, keySize, getAllAggregateRequests); if (logger.isTraceEnabled() && !storeName.contains("aggregate") && !storeName.contains("voldsys$")) logger.trace("Store '" + storeName + "' logged a " + op.toString() + " request taking " + ((double) timeNS / voldemort.utils.Time.NS_PER_MS) + " ms"); }
public void requestComplete(Object result, long requestTime) { if(logger.isTraceEnabled()) logger.trace(pipeline.getOperation().getSimpleName() + " response received (" + requestTime + " ms.) from node " + node.getId()); Response<ByteArray, Object> response = new Response<ByteArray, Object>(node, key, result, requestTime); if(logger.isTraceEnabled()) { logger.trace(attemptsLatch.getCount() + " attempts remaining. Will block " + " for " + blocksLatch.getCount() + " more "); } responses.put(node.getId(), response); if(response.getValue() instanceof Exception && isOperationCompleted.get()) { handleException(response, pipeline); } attemptsLatch.countDown(); blocksLatch.countDown(); } };
@Override public Map<ByteArray, List<Versioned<byte[]>>> getAll(Iterable<ByteArray> keys, Map<ByteArray, byte[]> transforms) throws VoldemortException { // TODO Does RocksDB multiget supports atomicity ? StoreUtils.assertValidKeys(keys); long startTimeNs = -1; if(logger.isTraceEnabled()) startTimeNs = System.nanoTime(); Map<ByteArray, List<Versioned<byte[]>>> results = null; try { results = StoreUtils.getAll(this, keys, transforms); } catch(PersistenceFailureException e) { logger.error(e); throw new PersistenceFailureException(e); } finally { if(logger.isTraceEnabled()) { String keyStr = ""; for(ByteArray key: keys) keyStr += key + " "; logger.trace("Completed GETALL (" + getName() + ") from keys " + keyStr + " in " + (System.nanoTime() - startTimeNs) + " ns at " + System.currentTimeMillis()); } } return results; }
@Override protected void write(SelectionKey selectionKey) throws IOException { if(!checkTimeout()) return; if(outputStream.getBuffer().hasRemaining()) { // If we have data, write what we can now... int count = socketChannel.write(outputStream.getBuffer()); if(logger.isTraceEnabled()) logger.trace("Wrote " + count + " bytes, remaining: " + outputStream.getBuffer().remaining() + " for " + socketChannel.socket()); } else { if(logger.isTraceEnabled()) logger.trace("Wrote no bytes for " + socketChannel.socket()); } // If there's more to write but we didn't write it, we'll take that to // mean that we're done here. We don't clear or reset anything. We leave // our buffer state where it is and try our luck next time. if(outputStream.getBuffer().hasRemaining()) return; resetStreams(); // If we're not streaming writes, signal the Selector that we're // ready to read the next request. selectionKey.interestOps(SelectionKey.OP_READ); }
private List<Versioned<byte[]>> getValueForKey(ByteArray key, byte[] transforms) throws PersistenceFailureException { long startTimeNs = -1; if(logger.isTraceEnabled()) startTimeNs = System.nanoTime(); List<Versioned<byte[]>> value = null; try { byte[] result = getRocksDB().get(storeHandle, key.get()); if(result != null) { value = StoreBinaryFormat.fromByteArray(result); } else { return Collections.emptyList(); } } catch(RocksDBException e) { logger.error(e); throw new PersistenceFailureException(e); } finally { if(logger.isTraceEnabled()) { logger.trace("Completed GET (" + getName() + ") from key " + key + " (keyRef: " + System.identityHashCode(key) + ") in " + (System.nanoTime() - startTimeNs) + " ns at " + System.currentTimeMillis()); } } return value; }
/** * Null out current clientRequest before calling complete. timeOut and * complete must *not* be within a synchronized block since both eventually * check in the client request executor. Such a check in can trigger * additional synchronized methods deeper in the stack. */ private ClientRequest<?> completeClientRequest() { ClientRequest<?> local = atomicNullOutClientRequest(); if(local == null) { return null; } if(isExpired) { local.timeOut(); } else { local.complete(); } if(logger.isTraceEnabled()) logger.trace("Marked client associated with " + socketChannel.socket() + " as complete"); return local; }
protected void setAvailable(Node node) { NodeStatus nodeStatus = getNodeStatus(node); if(logger.isTraceEnabled()) logger.trace("Node " + node.getId() + " set as available"); // We need to distinguish the case where we're newly available and the // case where we're getting redundant availability notices. So let's // check the node status before we update it. boolean previouslyAvailable = setAvailable(nodeStatus, true); // If we were not previously available, we've just switched state, // so notify any listeners. if(!previouslyAvailable) { if(logger.isInfoEnabled()) logger.info("Node " + node.getId() + " now available"); synchronized(nodeStatus) { nodeStatus.resetNumConsecutiveCatastrophicErrors(); if(logger.isTraceEnabled()) { logger.trace("Resetting # consecutive connect errors for node : " + node); } nodeStatus.notifyAll(); } for(FailureDetectorListener fdl: listeners.keySet()) { try { fdl.nodeAvailable(node); } catch(Exception e) { if(logger.isEnabledFor(Level.WARN)) logger.warn(e, e); } } } }
/** {@inheritDoc} */ @Override public void trace(String msg) { if (!impl.isTraceEnabled()) warning("Logging at TRACE level without checking if TRACE level is enabled: " + msg); impl.trace(msg); }
int count = socketChannel.write(outputStream.getBuffer()); if(logger.isTraceEnabled()) logger.trace("Wrote " + count + " bytes, remaining: " + outputStream.getBuffer().remaining() + " for " + socketChannel.socket()); if(logger.isTraceEnabled()) logger.trace("Wrote no bytes for " + socketChannel.socket()); if(logger.isTraceEnabled()) logger.trace("Request is streaming for " + socketChannel.socket());
/** * Detailed request to track additional data about PUT, GET and GET_ALL * * @param timeNS The time in nanoseconds that the operation took to complete * @param numEmptyResponses For GET and GET_ALL, how many keys were no values found * @param valueBytes Total number of bytes across all versions of values' bytes * @param keyBytes Total number of bytes in the keys * @param getAllAggregatedCount Total number of keys returned for getAll calls */ public void addRequest(long timeNS, long numEmptyResponses, long valueBytes, long keyBytes, long getAllAggregatedCount) { // timing instrumentation (trace only) long startTimeNs = 0; if(logger.isTraceEnabled()) { startTimeNs = System.nanoTime(); } long currentTime = time.milliseconds(); timeSensor.record((double) timeNS / voldemort.utils.Time.NS_PER_MS, currentTime); emptyResponseKeysSensor.record(numEmptyResponses, currentTime); valueBytesSensor.record(valueBytes, currentTime); keyBytesSensor.record(keyBytes, currentTime); getAllKeysCountSensor.record(getAllAggregatedCount, currentTime); // timing instrumentation (trace only) if(logger.isTraceEnabled()) { logger.trace("addRequest took " + (System.nanoTime() - startTimeNs) + " ns."); } }
@Override public synchronized List<Versioned<V>> multiVersionPut(K key, final List<Versioned<V>> values) { Boolean result = assertionMap.remove(key); if(result == null) { if(logger.isTraceEnabled()) { logger.trace("PUT key: " + key + " (never asserted) assertionMap size: " + assertionMap.size()); } } else { if(logger.isDebugEnabled()) { logger.debug("PUT key: " + key + " (found and fulfills put assertion) assertionMap size: " + assertionMap.size()); } } List<Versioned<V>> obsoleteVals = super.multiVersionPut(key, values); return obsoleteVals; }
if(logger.isTraceEnabled()) logger.trace(operation.getSimpleName() + " request, events complete due to error"); if(logger.isTraceEnabled()) logger.trace(operation.getSimpleName() + " request, events complete"); throw new IllegalStateException("action was null for event " + event); if(logger.isTraceEnabled()) logger.trace(operation.getSimpleName() + " request, action " + action.getClass().getSimpleName() + " to handle " + event + " event");
public synchronized void assertPut(K key) throws VoldemortException { StoreUtils.assertValidKey(key); // delete if exist List<Versioned<V>> result = map.remove(key); if(result == null || result.size() == 0) { // if non-exist, record as assertion assertionMap.put(key, true); // use synchronized to avoid race // condition here if(logger.isDebugEnabled()) { logger.debug("PUT Assertion added (not yet fulfilled) for key: " + key + " assertionMap size: " + assertionMap.size()); } } else { if(logger.isTraceEnabled()) { logger.trace("PUT Assertion added (immediately fulfilled) for key: " + key + " assertionMap size: " + assertionMap.size()); } } }