private void failed() { Tracing.trace("Payload application resulted in WriteTimeout, not replying"); }
private void failed() { Tracing.trace("Payload application resulted in WriteTimeout, not replying"); }
private void failed() { Tracing.trace("Payload application resulted in WriteTimeout, not replying"); }
public static ParsedStatement.Prepared getStatement(String queryStr, ClientState clientState) throws RequestValidationException { Tracing.trace("Parsing {}", queryStr); ParsedStatement statement = parseStatement(queryStr); // Set keyspace for statement that require login if (statement instanceof CFStatement) ((CFStatement)statement).prepareKeyspace(clientState); Tracing.trace("Preparing statement"); return statement.prepare(clientState); }
public static ParsedStatement.Prepared getStatement(String queryStr, ClientState clientState) throws RequestValidationException { Tracing.trace("Parsing {}", queryStr); ParsedStatement statement = parseStatement(queryStr); // Set keyspace for statement that require login if (statement instanceof CFStatement) ((CFStatement)statement).prepareKeyspace(clientState); Tracing.trace("Preparing statement"); return statement.prepare(clientState); }
public static ParsedStatement.Prepared getStatement(String queryStr, ClientState clientState) throws RequestValidationException { Tracing.trace("Parsing {}", queryStr); ParsedStatement statement = parseStatement(queryStr); // Set keyspace for statement that require login if (statement instanceof CFStatement) ((CFStatement)statement).prepareKeyspace(clientState); Tracing.trace("Preparing statement"); return statement.prepare(clientState); }
public static ParsedStatement.Prepared getStatement(String queryStr, ClientState clientState) throws RequestValidationException { Tracing.trace("Parsing {}", queryStr); ParsedStatement statement = parseStatement(queryStr); // Set keyspace for statement that require login if (statement instanceof CFStatement) ((CFStatement)statement).prepareKeyspace(clientState); Tracing.trace("Preparing statement"); return statement.prepare(); }
private PartitionIterator sendNextRequests() { List<PartitionIterator> concurrentQueries = new ArrayList<>(concurrencyFactor); for (int i = 0; i < concurrencyFactor && ranges.hasNext(); i++) { concurrentQueries.add(query(ranges.next(), i == 0)); ++rangesQueried; } Tracing.trace("Submitted {} concurrent range requests", concurrentQueries.size()); // We want to count the results for the sake of updating the concurrency factor (see updateConcurrencyFactor) but we don't want to // enforce any particular limit at this point (this could break code than rely on postReconciliationProcessing), hence the DataLimits.NONE. counter = DataLimits.NONE.newCounter(command.nowInSec(), true, command.selectsFullPartition(), enforceStrictLiveness); return counter.applyTo(PartitionIterators.concat(concurrentQueries)); }
private PartitionIterator sendNextRequests() { List<PartitionIterator> concurrentQueries = new ArrayList<>(concurrencyFactor); for (int i = 0; i < concurrencyFactor && ranges.hasNext(); i++) { concurrentQueries.add(query(ranges.next(), i == 0)); ++rangesQueried; } Tracing.trace("Submitted {} concurrent range requests", concurrentQueries.size()); // We want to count the results for the sake of updating the concurrency factor (see updateConcurrencyFactor) but we don't want to // enforce any particular limit at this point (this could break code than rely on postReconciliationProcessing), hence the DataLimits.NONE. counter = DataLimits.NONE.newCounter(command.nowInSec(), true, command.selectsFullPartition(), enforceStrictLiveness); return counter.applyTo(PartitionIterators.concat(concurrentQueries)); }
private void reply(int id, InetAddress replyTo) { Tracing.trace("Enqueuing response to {}", replyTo); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, replyTo); }
private void reply(int id, InetAddress replyTo) { Tracing.trace("Enqueuing response to {}", replyTo); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, replyTo); }
private void reply(int id, InetAddress replyTo) { Tracing.trace("Enqueuing response to {}", replyTo); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, replyTo); }
public ByteBuffer compute(ProtocolVersion protocolVersion) throws InvalidRequestException { maybeInit(protocolVersion); // final function is traced in UDFunction Tracing.trace("Executed UDA {}: {} call(s) to state function {} in {}\u03bcs", name(), stateFunctionCount, stateFunction.name(), stateFunctionDuration); if (finalFunction == null) return UDFunction.decompose(stateTypeCodec, protocolVersion, state); if (finalFunction instanceof UDFunction) { UDFunction udf = (UDFunction)finalFunction; Object result = udf.executeForAggregate(protocolVersion, state, Collections.emptyList()); return UDFunction.decompose(returnTypeCodec, protocolVersion, result); } throw new UnsupportedOperationException("UDAs only support UDFs"); }
public void doVerb(MessageIn<Commit> message, int id) { PaxosState.commit(message.payload); Tracing.trace("Enqueuing acknowledge to {}", message.from); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, message.from); } }
public void doVerb(MessageIn<Commit> message, int id) { PaxosState.commit(message.payload); Tracing.trace("Enqueuing acknowledge to {}", message.from); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, message.from); } }
public void doVerb(MessageIn<Commit> message, int id) { PaxosState.commit(message.payload); Tracing.trace("Enqueuing acknowledge to {}", message.from); MessagingService.instance().sendReply(WriteResponse.createMessage(), id, message.from); } }
public List<Row> search(ExtendedFilter filter) { Tracing.trace("Executing indexed scan for {}", filter.dataRange.keyRange().getString(metadata.getKeyValidator())); return indexManager.search(filter); }
public TResolved get() throws ReadTimeoutException, DigestMismatchException { if (!await(command.getTimeout(), TimeUnit.MILLISECONDS)) { // Same as for writes, see AbstractWriteResponseHandler ReadTimeoutException ex = new ReadTimeoutException(consistencyLevel, received, blockfor, resolver.isDataPresent()); Tracing.trace("Read timeout: {}", ex.toString()); if (logger.isDebugEnabled()) logger.debug("Read timeout: {}", ex.toString()); throw ex; } return blockfor == 1 ? resolver.getData() : resolver.resolve(); }
public void doVerb(MessageIn<Commit> message, int id) { PaxosState.commit(message.payload); WriteResponse response = new WriteResponse(); Tracing.trace("Enqueuing acknowledge to {}", message.from); MessagingService.instance().sendReply(response.createMessage(), id, message.from); } }
public ColumnFamily getTopLevelColumns(QueryFilter filter, int gcBefore) { Tracing.trace("Executing single-partition query on {}", name); CollationController controller = new CollationController(this, filter, gcBefore); ColumnFamily columns; try (OpOrder.Group op = readOrdering.start()) { columns = controller.getTopLevelColumns(Memtable.MEMORY_POOL.needToCopyOnHeap()); } if (columns != null) metric.samplers.get(Sampler.READS).addSample(filter.key.getKey(), filter.key.hashCode(), 1); metric.updateSSTableIterated(controller.getSstablesIterated()); return columns; }