diff --git a/NEWS.txt b/NEWS.txt index 78d90f6143..6bd0a77908 100644 --- a/NEWS.txt +++ b/NEWS.txt @@ -31,12 +31,22 @@ Changed Defaults providing the '-full' parameter to nodetool repair. - Parallel repairs are the default since 2.2.0, run sequential repairs by providing the '-seq' parameter to nodetool repair. + - The following INFO logs were reduced to DEBUG level and will now show + on debug.log instead of system.log: + - Memtable flushing actions + - Commit log replayed files + - Compacted sstables + - SStable opening (SSTableReader) New features ------------ - Custom QueryHandlers can retrieve the column specifications for the bound variables from QueryOptions by using the hasColumnSpecifications() and getColumnSpecifications() methods. + - A new default assynchronous log appender debug.log was created in addition + to the system.log appender in order to provide more detailed log debugging. + In order to disable debug logging, you must comment-out the ASYNCDEBUGLOG + appender on conf/logback.xml. See CASSANDRA-10241 for more information. 2.2.1 diff --git a/conf/logback.xml b/conf/logback.xml index eb2dcd1b96..a47740d70c 100644 --- a/conf/logback.xml +++ b/conf/logback.xml @@ -17,28 +17,67 @@ under the License. --> + + - + + + + + + + INFO + ${cassandra.logdir}/system.log ${cassandra.logdir}/system.log.%i.zip 1 20 - 20MB %-5level [%thread] %date{ISO8601} %F:%L - %msg%n - - + + + + + ${cassandra.logdir}/debug.log + + ${cassandra.logdir}/debug.log.%i.zip + 1 + 20 + + + 20MB + + + %-5level [%thread] %date{ISO8601} %F:%L - %msg%n + + + + + + + 1024 + 0 + true + + + + + + + INFO + %-5level %date{HH:mm:ss,SSS} %msg%n @@ -49,12 +88,14 @@ --> - + + - + + diff --git a/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java b/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java index 5cdea3fdbd..88069a233b 100644 --- a/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java +++ b/src/java/org/apache/cassandra/auth/CassandraAuthorizer.java @@ -439,7 +439,7 @@ public class CassandraAuthorizer implements IAuthorizer { logger.info("Unable to complete conversion of legacy permissions data (perhaps not enough nodes are upgraded yet). " + "Conversion should not be considered complete"); - logger.debug("Conversion error", e); + logger.trace("Conversion error", e); } } diff --git a/src/java/org/apache/cassandra/auth/CassandraRoleManager.java b/src/java/org/apache/cassandra/auth/CassandraRoleManager.java index 9151958557..3a5958150c 100644 --- a/src/java/org/apache/cassandra/auth/CassandraRoleManager.java +++ b/src/java/org/apache/cassandra/auth/CassandraRoleManager.java @@ -376,7 +376,7 @@ public class CassandraRoleManager implements IRoleManager // will be finished by then. if (!MessagingService.instance().areAllNodesAtLeast22()) { - logger.debug("Not all nodes are upgraded to a version that supports Roles yet, rescheduling setup task"); + logger.trace("Not all nodes are upgraded to a version that supports Roles yet, rescheduling setup task"); scheduleSetupTask(setupTask); return; } @@ -442,7 +442,7 @@ public class CassandraRoleManager implements IRoleManager { logger.info("Unable to complete conversion of legacy auth data (perhaps not enough nodes are upgraded yet). " + "Conversion should not be considered complete"); - logger.debug("Conversion error", e); + logger.trace("Conversion error", e); throw e; } } diff --git a/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java b/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java index 87bc073220..c0d2283a14 100644 --- a/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java +++ b/src/java/org/apache/cassandra/auth/PasswordAuthenticator.java @@ -86,7 +86,7 @@ public class PasswordAuthenticator implements IAuthenticator } catch (RequestExecutionException e) { - logger.debug("Error performing internal authentication", e); + logger.trace("Error performing internal authentication", e); throw new AuthenticationException(e.toString()); } } @@ -196,7 +196,7 @@ public class PasswordAuthenticator implements IAuthenticator */ private void decodeCredentials(byte[] bytes) throws AuthenticationException { - logger.debug("Decoding credentials from client token"); + logger.trace("Decoding credentials from client token"); byte[] user = null; byte[] pass = null; int end = bytes.length; diff --git a/src/java/org/apache/cassandra/auth/PermissionsCache.java b/src/java/org/apache/cassandra/auth/PermissionsCache.java index bc96d829a7..8746b36e5d 100644 --- a/src/java/org/apache/cassandra/auth/PermissionsCache.java +++ b/src/java/org/apache/cassandra/auth/PermissionsCache.java @@ -137,7 +137,7 @@ public class PermissionsCache implements PermissionsCacheMBean } catch (Exception e) { - logger.debug("Error performing async refresh of user permissions", e); + logger.trace("Error performing async refresh of user permissions", e); throw e; } } diff --git a/src/java/org/apache/cassandra/auth/RolesCache.java b/src/java/org/apache/cassandra/auth/RolesCache.java index 58aa739534..554df9e854 100644 --- a/src/java/org/apache/cassandra/auth/RolesCache.java +++ b/src/java/org/apache/cassandra/auth/RolesCache.java @@ -135,7 +135,7 @@ public class RolesCache implements RolesCacheMBean return roleManager.getRoles(primaryRole, true); } catch (Exception e) { - logger.debug("Error performing async refresh of user roles", e); + logger.trace("Error performing async refresh of user roles", e); throw e; } } diff --git a/src/java/org/apache/cassandra/cache/AutoSavingCache.java b/src/java/org/apache/cassandra/cache/AutoSavingCache.java index 48d60b7c96..c08925d735 100644 --- a/src/java/org/apache/cassandra/cache/AutoSavingCache.java +++ b/src/java/org/apache/cassandra/cache/AutoSavingCache.java @@ -256,8 +256,8 @@ public class AutoSavingCache extends InstrumentingCache extends InstrumentingCache implements ICache } catch (IOException e) { - logger.debug("Cannot fetch in memory data, we will fallback to read from disk ", e); + logger.trace("Cannot fetch in memory data, we will fallback to read from disk ", e); return null; } } diff --git a/src/java/org/apache/cassandra/client/RingCache.java b/src/java/org/apache/cassandra/client/RingCache.java index 094cf4fb3a..5196bcec5c 100644 --- a/src/java/org/apache/cassandra/client/RingCache.java +++ b/src/java/org/apache/cassandra/client/RingCache.java @@ -93,7 +93,7 @@ public class RingCache } catch (TException e) { - logger.debug("Error contacting seed list {} {}", ConfigHelper.getOutputInitialAddress(conf), e.getMessage()); + logger.trace("Error contacting seed list {} {}", ConfigHelper.getOutputInitialAddress(conf), e.getMessage()); } } diff --git a/src/java/org/apache/cassandra/concurrent/DebuggableScheduledThreadPoolExecutor.java b/src/java/org/apache/cassandra/concurrent/DebuggableScheduledThreadPoolExecutor.java index ea0715cc7f..a722b8766d 100644 --- a/src/java/org/apache/cassandra/concurrent/DebuggableScheduledThreadPoolExecutor.java +++ b/src/java/org/apache/cassandra/concurrent/DebuggableScheduledThreadPoolExecutor.java @@ -54,7 +54,7 @@ public class DebuggableScheduledThreadPoolExecutor extends ScheduledThreadPoolEx if (task instanceof Future) ((Future) task).cancel(false); - logger.debug("ScheduledThreadPoolExecutor has shut down as part of C* shutdown"); + logger.trace("ScheduledThreadPoolExecutor has shut down as part of C* shutdown"); } else { diff --git a/src/java/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutor.java b/src/java/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutor.java index fe6cadecd9..a6d00498fd 100644 --- a/src/java/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutor.java +++ b/src/java/org/apache/cassandra/concurrent/DebuggableThreadPoolExecutor.java @@ -266,7 +266,7 @@ public class DebuggableThreadPoolExecutor extends ThreadPoolExecutor implements } catch (CancellationException e) { - logger.debug("Task cancelled", e); + logger.trace("Task cancelled", e); } catch (ExecutionException e) { diff --git a/src/java/org/apache/cassandra/cql3/QueryProcessor.java b/src/java/org/apache/cassandra/cql3/QueryProcessor.java index 161d8d0ff7..30a111d72a 100644 --- a/src/java/org/apache/cassandra/cql3/QueryProcessor.java +++ b/src/java/org/apache/cassandra/cql3/QueryProcessor.java @@ -618,20 +618,20 @@ public class QueryProcessor implements QueryHandler public void onUpdateColumnFamily(String ksName, String cfName, boolean columnsDidChange) { - logger.debug("Column definitions for {}.{} changed, invalidating related prepared statements", ksName, cfName); + logger.trace("Column definitions for {}.{} changed, invalidating related prepared statements", ksName, cfName); if (columnsDidChange) removeInvalidPreparedStatements(ksName, cfName); } public void onDropKeyspace(String ksName) { - logger.debug("Keyspace {} was dropped, invalidating related prepared statements", ksName); + logger.trace("Keyspace {} was dropped, invalidating related prepared statements", ksName); removeInvalidPreparedStatements(ksName, null); } public void onDropColumnFamily(String ksName, String cfName) { - logger.debug("Table {}.{} was dropped, invalidating related prepared statements", ksName, cfName); + logger.trace("Table {}.{} was dropped, invalidating related prepared statements", ksName, cfName); removeInvalidPreparedStatements(ksName, cfName); } diff --git a/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java b/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java index 97a08b1daa..c40e03107d 100644 --- a/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java +++ b/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java @@ -170,7 +170,7 @@ public final class JavaSourceUDFFactory String javaSource = javaSourceBuilder.toString(); - logger.debug("Compiling Java source UDF '{}' as class '{}' using source:\n{}", name, targetClassName, javaSource); + logger.trace("Compiling Java source UDF '{}' as class '{}' using source:\n{}", name, targetClassName, javaSource); try { @@ -303,7 +303,7 @@ public final class JavaSourceUDFFactory if (i > 0) code.append(",\n"); - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) code.append(" /* parameter '").append(argNames.get(i)).append("' */\n"); code diff --git a/src/java/org/apache/cassandra/cql3/functions/ScriptBasedUDF.java b/src/java/org/apache/cassandra/cql3/functions/ScriptBasedUDF.java index 4d9a79fd68..e55d450883 100644 --- a/src/java/org/apache/cassandra/cql3/functions/ScriptBasedUDF.java +++ b/src/java/org/apache/cassandra/cql3/functions/ScriptBasedUDF.java @@ -143,7 +143,7 @@ public class ScriptBasedUDF extends UDFunction } catch (RuntimeException | ScriptException e) { - logger.debug("Execution of UDF '{}' failed", name, e); + logger.trace("Execution of UDF '{}' failed", name, e); throw FunctionExecutionException.create(this, e); } } diff --git a/src/java/org/apache/cassandra/cql3/statements/CreateIndexStatement.java b/src/java/org/apache/cassandra/cql3/statements/CreateIndexStatement.java index c3b0993006..edc092d684 100644 --- a/src/java/org/apache/cassandra/cql3/statements/CreateIndexStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/CreateIndexStatement.java @@ -164,7 +164,7 @@ public class CreateIndexStatement extends SchemaAlteringStatement { CFMetaData cfm = Schema.instance.getCFMetaData(keyspace(), columnFamily()).copy(); IndexTarget target = rawTarget.prepare(cfm); - logger.debug("Updating column {} definition for index {}", target.column, indexName); + logger.trace("Updating column {} definition for index {}", target.column, indexName); ColumnDefinition cd = cfm.getColumnDefinition(target.column); if (cd.getIndexType() != null && ifNotExists) diff --git a/src/java/org/apache/cassandra/db/BatchlogManager.java b/src/java/org/apache/cassandra/db/BatchlogManager.java index 1c1b37b1b2..ba56f0d95d 100644 --- a/src/java/org/apache/cassandra/db/BatchlogManager.java +++ b/src/java/org/apache/cassandra/db/BatchlogManager.java @@ -163,7 +163,7 @@ public class BatchlogManager implements BatchlogManagerMBean private void replayAllFailedBatches() throws ExecutionException, InterruptedException { - logger.debug("Started replayAllFailedBatches"); + logger.trace("Started replayAllFailedBatches"); // rate limit is in bytes per second. Uses Double.MAX_VALUE if disabled (set to 0 in cassandra.yaml). // max rate is scaled by the number of nodes in the cluster (same as for HHOM - see CASSANDRA-5272). @@ -191,7 +191,7 @@ public class BatchlogManager implements BatchlogManagerMBean cleanup(); - logger.debug("Finished replayAllFailedBatches"); + logger.trace("Finished replayAllFailedBatches"); } private void deleteBatch(UUID id) @@ -274,7 +274,7 @@ public class BatchlogManager implements BatchlogManagerMBean public int replay(RateLimiter rateLimiter) throws IOException { - logger.debug("Replaying batch {}", id); + logger.trace("Replaying batch {}", id); List mutations = replayingMutations(); @@ -303,8 +303,8 @@ public class BatchlogManager implements BatchlogManagerMBean } catch (WriteTimeoutException|WriteFailureException e) { - logger.debug("Failed replaying a batched mutation to a node, will write a hint"); - logger.debug("Failure was : {}", e.getMessage()); + logger.trace("Failed replaying a batched mutation to a node, will write a hint"); + logger.trace("Failure was : {}", e.getMessage()); // writing hints for the rest to hints, starting from i writeHintsForUndeliveredEndpoints(i); return; diff --git a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java index a8a891053c..4b418b46be 100644 --- a/src/java/org/apache/cassandra/db/ColumnFamilyStore.java +++ b/src/java/org/apache/cassandra/db/ColumnFamilyStore.java @@ -217,7 +217,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean int period = metadata.getMemtableFlushPeriod(); if (period > 0) { - logger.debug("scheduling flush in {} ms", period); + logger.trace("scheduling flush in {} ms", period); WrappedRunnable runnable = new WrappedRunnable() { protected void runMayThrow() throws Exception @@ -422,7 +422,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { throw new RuntimeException(e); } - logger.debug("retryPolicy for {} is {}", name, this.metadata.getSpeculativeRetry()); + logger.trace("retryPolicy for {} is {}", name, this.metadata.getSpeculativeRetry()); latencyCalculator = ScheduledExecutors.optionalTasks.scheduleWithFixedDelay(new Runnable() { public void run() @@ -570,7 +570,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean } } - logger.debug("Removing compacted SSTable files from {} (see http://wiki.apache.org/cassandra/MemtableSSTable)", metadata.cfName); + logger.trace("Removing compacted SSTable files from {} (see http://wiki.apache.org/cassandra/MemtableSSTable)", metadata.cfName); for (Map.Entry> sstableFiles : directories.sstableLister().list().entrySet()) { @@ -649,7 +649,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { HashSet missingGenerations = new HashSet<>(unfinishedGenerations); missingGenerations.removeAll(allGenerations); - logger.debug("Unfinished compactions of {}.{} reference missing sstables of generations {}", + logger.trace("Unfinished compactions of {}.{} reference missing sstables of generations {}", metadata.ksName, metadata.cfName, missingGenerations); } @@ -682,7 +682,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean // any of the ancestors would work, so we'll just lookup the compaction task ID with the first one UUID compactionTaskID = unfinishedCompactions.get(ancestors.iterator().next()); assert compactionTaskID != null; - logger.debug("Going to delete unfinished compaction product {}", desc); + logger.trace("Going to delete unfinished compaction product {}", desc); SSTable.delete(desc, sstableFiles.getValue()); SystemKeyspace.finishCompaction(compactionTaskID); } @@ -699,7 +699,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean if (completedAncestors.contains(desc.generation)) { // if any of the ancestors were participating in a compaction, finish that compaction - logger.debug("Going to delete leftover compaction ancestor {}", desc); + logger.trace("Going to delete leftover compaction ancestor {}", desc); SSTable.delete(desc, sstableFiles.getValue()); UUID compactionTaskID = unfinishedCompactions.get(desc.generation); if (compactionTaskID != null) @@ -916,7 +916,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean } } - logger.info("Enqueuing flush of {}: {}", name, String.format("%d (%.0f%%) on-heap, %d (%.0f%%) off-heap", + logger.debug("Enqueuing flush of {}: {}", name, String.format("%d (%.0f%%) on-heap, %d (%.0f%%) off-heap", onHeapTotal, onHeapRatio * 100, offHeapTotal, offHeapRatio * 100)); } @@ -955,7 +955,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { public void run() { - logger.debug("forceFlush requested but everything is clean in {}", name); + logger.trace("forceFlush requested but everything is clean in {}", name); } }, null); postFlushExecutor.execute(task); @@ -1208,7 +1208,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean float flushingOffHeap = Memtable.MEMORY_POOL.offHeap.reclaimingRatio(); float thisOnHeap = largest.getAllocator().onHeap().ownershipRatio(); float thisOffHeap = largest.getAllocator().onHeap().ownershipRatio(); - logger.info("Flushing largest {} to free up room. Used total: {}, live: {}, flushing: {}, this: {}", + logger.debug("Flushing largest {} to free up room. Used total: {}, live: {}, flushing: {}, this: {}", largest.cfs, ratio(usedOnHeap, usedOffHeap), ratio(liveOnHeap, liveOffHeap), ratio(flushingOnHeap, flushingOffHeap), ratio(thisOnHeap, thisOffHeap)); largest.cfs.switchMemtableIfCurrent(largest); @@ -1343,7 +1343,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean */ public Collection getOverlappingSSTables(Iterable sstables) { - logger.debug("Checking for sstables overlapping {}", sstables); + logger.trace("Checking for sstables overlapping {}", sstables); // a normal compaction won't ever have an empty sstables list, but we create a skeleton // compaction controller for streaming, and that passes an empty list. @@ -1972,7 +1972,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean } } - logger.debug("ViewFilter for {}/{} sstables", sstables.size(), getSSTables().size()); + logger.trace("ViewFilter for {}/{} sstables", sstables.size(), getSSTables().size()); return ImmutableList.copyOf(sstables); } }; @@ -2328,8 +2328,8 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean ssTable.createLinks(snapshotDirectory.getPath()); // hard links filesJSONArr.add(ssTable.descriptor.relativeFilenameFor(Component.DATA)); - if (logger.isDebugEnabled()) - logger.debug("Snapshot for {} keyspace data file {} created in {}", keyspace, ssTable.getFilename(), snapshotDirectory); + if (logger.isTraceEnabled()) + logger.trace("Snapshot for {} keyspace data file {} created in {}", keyspace, ssTable.getFilename(), snapshotDirectory); snapshottedSSTables.add(ssTable); } @@ -2373,7 +2373,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean ephemeralSnapshotMarker.getParentFile().mkdirs(); Files.createFile(ephemeralSnapshotMarker.toPath()); - logger.debug("Created ephemeral snapshot marker file on {}.", ephemeralSnapshotMarker.getAbsolutePath()); + logger.trace("Created ephemeral snapshot marker file on {}.", ephemeralSnapshotMarker.getAbsolutePath()); } catch (IOException e) { @@ -2388,7 +2388,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { for (String ephemeralSnapshot : directories.listEphemeralSnapshots()) { - logger.debug("Clearing ephemeral snapshot {} leftover from previous session.", ephemeralSnapshot); + logger.trace("Clearing ephemeral snapshot {} leftover from previous session.", ephemeralSnapshot); Directories.clearSnapshot(ephemeralSnapshot, directories.getCFDirectories()); } } @@ -2409,17 +2409,17 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean SSTableReader sstable = active.get(entries.getKey().generation); if (sstable == null || !refs.tryRef(sstable)) { - if (logger.isDebugEnabled()) - logger.debug("using snapshot sstable {}", entries.getKey()); + if (logger.isTraceEnabled()) + logger.trace("using snapshot sstable {}", entries.getKey()); // open without tracking hotness sstable = SSTableReader.open(entries.getKey(), entries.getValue(), metadata, partitioner, true, false); refs.tryRef(sstable); // release the self ref as we never add the snapshot sstable to DataTracker where it is otherwise released sstable.selfRef().release(); } - else if (logger.isDebugEnabled()) + else if (logger.isTraceEnabled()) { - logger.debug("using active sstable {}", entries.getKey()); + logger.trace("using active sstable {}", entries.getKey()); } } } @@ -2634,7 +2634,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean // beginning if we restart before they [the CL segments] are discarded for // normal reasons post-truncate. To prevent this, we store truncation // position in the System keyspace. - logger.debug("truncating {}", name); + logger.trace("truncating {}", name); if (keyspace.getMetadata().durableWrites || DatabaseDescriptor.isAutoSnapshot()) { @@ -2660,7 +2660,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean { public void run() { - logger.debug("Discarding sstable data for truncated CF + indexes"); + logger.trace("Discarding sstable data for truncated CF + indexes"); final long truncatedAt = System.currentTimeMillis(); data.notifyTruncated(truncatedAt); @@ -2674,13 +2674,13 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean index.truncateBlocking(truncatedAt); SystemKeyspace.saveTruncationRecord(ColumnFamilyStore.this, truncatedAt, replayAfter); - logger.debug("cleaning out row cache"); + logger.trace("cleaning out row cache"); invalidateCaches(); } }; runWithCompactionsDisabled(Executors.callable(truncateRunnable), true); - logger.debug("truncate complete"); + logger.trace("truncate complete"); } public V runWithCompactionsDisabled(Callable callable, boolean interruptValidation) @@ -2689,7 +2689,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean // and so we only run one major compaction at a time synchronized (this) { - logger.debug("Cancelling in-progress compactions for {}", metadata.cfName); + logger.trace("Cancelling in-progress compactions for {}", metadata.cfName); Iterable selfWithIndexes = concatWithIndexes(); for (ColumnFamilyStore cfs : selfWithIndexes) @@ -2709,7 +2709,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean return null; } } - logger.debug("Compactions successfully cancelled"); + logger.trace("Compactions successfully cancelled"); // run our task try diff --git a/src/java/org/apache/cassandra/db/ConsistencyLevel.java b/src/java/org/apache/cassandra/db/ConsistencyLevel.java index d49d66aee5..85ec0f31cc 100644 --- a/src/java/org/apache/cassandra/db/ConsistencyLevel.java +++ b/src/java/org/apache/cassandra/db/ConsistencyLevel.java @@ -260,7 +260,7 @@ public enum ConsistencyLevel int localLive = countLocalEndpoints(liveEndpoints); if (localLive < blockFor) { - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { StringBuilder builder = new StringBuilder("Local replicas ["); for (InetAddress endpoint : liveEndpoints) @@ -269,7 +269,7 @@ public enum ConsistencyLevel builder.append(endpoint).append(","); } builder.append("] are insufficient to satisfy LOCAL_QUORUM requirement of ").append(blockFor).append(" live nodes in '").append(DatabaseDescriptor.getLocalDataCenter()).append("'"); - logger.debug(builder.toString()); + logger.trace(builder.toString()); } throw new UnavailableException(this, blockFor, localLive); } @@ -291,7 +291,7 @@ public enum ConsistencyLevel int live = Iterables.size(liveEndpoints); if (live < blockFor) { - logger.debug("Live nodes {} do not satisfy ConsistencyLevel ({} required)", Iterables.toString(liveEndpoints), blockFor); + logger.trace("Live nodes {} do not satisfy ConsistencyLevel ({} required)", Iterables.toString(liveEndpoints), blockFor); throw new UnavailableException(this, blockFor, live); } break; diff --git a/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java b/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java index d9ee38a540..4dd8ac39e5 100644 --- a/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java +++ b/src/java/org/apache/cassandra/db/CounterMutationVerbHandler.java @@ -35,7 +35,7 @@ public class CounterMutationVerbHandler implements IVerbHandler public void doVerb(final MessageIn message, final int id) { final CounterMutation cm = message.payload; - logger.debug("Applying forwarded {}", cm); + logger.trace("Applying forwarded {}", cm); String localDataCenter = DatabaseDescriptor.getEndpointSnitch().getDatacenter(FBUtilities.getBroadcastAddress()); // We should not wait for the result of the write in this thread, diff --git a/src/java/org/apache/cassandra/db/DefinitionsUpdateVerbHandler.java b/src/java/org/apache/cassandra/db/DefinitionsUpdateVerbHandler.java index d5ede03c05..51d15b4cd7 100644 --- a/src/java/org/apache/cassandra/db/DefinitionsUpdateVerbHandler.java +++ b/src/java/org/apache/cassandra/db/DefinitionsUpdateVerbHandler.java @@ -41,7 +41,7 @@ public class DefinitionsUpdateVerbHandler implements IVerbHandler> message, int id) { - logger.debug("Received schema mutation push from {}", message.from); + logger.trace("Received schema mutation push from {}", message.from); StageManager.getStage(Stage.MIGRATION).submit(new WrappedRunnable() { diff --git a/src/java/org/apache/cassandra/db/Directories.java b/src/java/org/apache/cassandra/db/Directories.java index 0011baf3c3..066b7593c1 100644 --- a/src/java/org/apache/cassandra/db/Directories.java +++ b/src/java/org/apache/cassandra/db/Directories.java @@ -258,7 +258,7 @@ public class Directories for (File indexFile : indexFiles) { File destFile = new File(dataPath, indexFile.getName()); - logger.debug("Moving index file {} to {}", indexFile, destFile); + logger.trace("Moving index file {} to {}", indexFile, destFile); FileUtils.renameWithConfirm(indexFile, destFile); } } @@ -329,14 +329,14 @@ public class Directories { if (BlacklistedDirectories.isUnwritable(getLocationForDisk(dataDir))) { - logger.debug("removing blacklisted candidate {}", dataDir.location); + logger.trace("removing blacklisted candidate {}", dataDir.location); continue; } DataDirectoryCandidate candidate = new DataDirectoryCandidate(dataDir); // exclude directory if its total writeSize does not fit to data directory if (candidate.availableSpace < writeSize) { - logger.debug("removing candidate {}, usable={}, requested={}", candidate.dataDirectory.location, candidate.availableSpace, writeSize); + logger.trace("removing candidate {}, usable={}, requested={}", candidate.dataDirectory.location, candidate.availableSpace, writeSize); tooBig = true; continue; } @@ -728,7 +728,7 @@ public class Directories File snapshotDir = new File(dir, join(SNAPSHOT_SUBDIR, tag)); if (snapshotDir.exists()) { - logger.debug("Removing snapshot directory {}", snapshotDir); + logger.trace("Removing snapshot directory {}", snapshotDir); try { FileUtils.deleteRecursive(snapshotDir); diff --git a/src/java/org/apache/cassandra/db/HintedHandOffManager.java b/src/java/org/apache/cassandra/db/HintedHandOffManager.java index dae85b76af..179c611b92 100644 --- a/src/java/org/apache/cassandra/db/HintedHandOffManager.java +++ b/src/java/org/apache/cassandra/db/HintedHandOffManager.java @@ -175,7 +175,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean { throw new RuntimeException(e); } - logger.debug("Created HHOM instance, registered MBean."); + logger.trace("Created HHOM instance, registered MBean."); Runnable runnable = new Runnable() { @@ -317,7 +317,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean } if (gossiper.getEndpointStateForEndpoint(endpoint) == null) throw new TimeoutException("Node " + endpoint + " vanished while waiting for agreement"); - logger.debug("schema for {} matches local schema", endpoint); + logger.trace("schema for {} matches local schema", endpoint); return waited; } @@ -329,11 +329,11 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean // check if hints delivery has been paused if (hintedHandOffPaused) { - logger.debug("Hints delivery process is paused, aborting"); + logger.trace("Hints delivery process is paused, aborting"); return; } - logger.debug("Checking remote({}) schema before delivering hints", endpoint); + logger.trace("Checking remote({}) schema before delivering hints", endpoint); try { waitForSchemaAgreement(endpoint); @@ -345,7 +345,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean if (!FailureDetector.instance.isAlive(endpoint)) { - logger.debug("Endpoint {} died before hint delivery, aborting", endpoint); + logger.trace("Endpoint {} died before hint delivery, aborting", endpoint); return; } @@ -370,7 +370,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean Composite startColumn = Composites.EMPTY; int pageSize = calculatePageSize(); - logger.debug("Using pageSize of {}", pageSize); + logger.trace("Using pageSize of {}", pageSize); // rate limit is in bytes per second. Uses Double.MAX_VALUE if disabled (set to 0 in cassandra.yaml). // max rate is scaled by the number of nodes in the cluster (CASSANDRA-5272). @@ -411,7 +411,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean // check if hints delivery has been paused during the process if (hintedHandOffPaused) { - logger.debug("Hints delivery process is paused, aborting"); + logger.trace("Hints delivery process is paused, aborting"); break delivery; } @@ -434,7 +434,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean } catch (UnknownColumnFamilyException e) { - logger.debug("Skipping delivery of hint for deleted table", e); + logger.trace("Skipping delivery of hint for deleted table", e); deleteHint(hostIdBytes, hint.name(), hint.timestamp()); continue; } @@ -447,7 +447,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean { if (hint.timestamp() <= SystemKeyspace.getTruncatedAt(cfId)) { - logger.debug("Skipping delivery of hint for truncated table {}", cfId); + logger.trace("Skipping delivery of hint for truncated table {}", cfId); mutation = mutation.without(cfId); } } @@ -513,7 +513,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean */ private void scheduleAllDeliveries() { - logger.debug("Started scheduleAllDeliveries"); + logger.trace("Started scheduleAllDeliveries"); // Force a major compaction to get rid of the tombstones and expired hints. Do it once, before we schedule any // individual replay, to avoid N - 1 redundant individual compactions (when N is the number of nodes with hints @@ -534,7 +534,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean scheduleHintDelivery(target, false); } - logger.debug("Finished scheduleAllDeliveries"); + logger.trace("Finished scheduleAllDeliveries"); } /* @@ -548,7 +548,7 @@ public class HintedHandOffManager implements HintedHandOffManagerMBean if (!queuedDeliveries.add(to)) return; - logger.debug("Scheduling delivery of Hints to {}", to); + logger.trace("Scheduling delivery of Hints to {}", to); hintDeliveryExecutor.execute(new Runnable() { diff --git a/src/java/org/apache/cassandra/db/Keyspace.java b/src/java/org/apache/cassandra/db/Keyspace.java index feb3c5e9d5..92a09508dc 100644 --- a/src/java/org/apache/cassandra/db/Keyspace.java +++ b/src/java/org/apache/cassandra/db/Keyspace.java @@ -266,7 +266,7 @@ public class Keyspace this.metric = new KeyspaceMetrics(this); for (CFMetaData cfm : new ArrayList<>(metadata.cfMetaData().values())) { - logger.debug("Initializing {}.{}", getName(), cfm.cfName); + logger.trace("Initializing {}.{}", getName(), cfm.cfName); initCf(cfm.cfId, cfm.cfName, loadSSTables); } } @@ -420,8 +420,8 @@ public class Keyspace */ public static void indexRow(DecoratedKey key, ColumnFamilyStore cfs, Set idxNames) { - if (logger.isDebugEnabled()) - logger.debug("Indexing row {} ", cfs.metadata.getKeyValidator().getString(key.getKey())); + if (logger.isTraceEnabled()) + logger.trace("Indexing row {} ", cfs.metadata.getKeyValidator().getString(key.getKey())); try (OpOrder.Group opGroup = cfs.keyspace.writeOrder.start()) { diff --git a/src/java/org/apache/cassandra/db/Memtable.java b/src/java/org/apache/cassandra/db/Memtable.java index 1ce2b9f4c2..e96a71e605 100644 --- a/src/java/org/apache/cassandra/db/Memtable.java +++ b/src/java/org/apache/cassandra/db/Memtable.java @@ -360,13 +360,13 @@ public class Memtable implements Comparable private SSTableReader writeSortedContents(ReplayPosition context, File sstableDirectory) { - logger.info("Writing {}", Memtable.this.toString()); + logger.debug("Writing {}", Memtable.this.toString()); SSTableReader ssTable; // errors when creating the writer that may leave empty temp files. try (SSTableWriter writer = createFlushWriter(cfs.getTempSSTablePath(sstableDirectory))) { - boolean trackContention = logger.isDebugEnabled(); + boolean trackContention = logger.isTraceEnabled(); int heavilyContendedRowCount = 0; // (we can't clear out the map as-we-go to free up memory, // since the memtable is being used for queries in the "pending flush" category) @@ -394,7 +394,7 @@ public class Memtable implements Comparable if (writer.getFilePointer() > 0) { - logger.info(String.format("Completed flushing %s (%s) for commitlog position %s", + logger.debug(String.format("Completed flushing %s (%s) for commitlog position %s", writer.getFilename(), FBUtilities.prettyPrintMemory(writer.getOnDiskFilePointer()), context)); @@ -404,14 +404,14 @@ public class Memtable implements Comparable } else { - logger.info("Completed flushing {}; nothing needed to be retained. Commitlog position was {}", + logger.debug("Completed flushing {}; nothing needed to be retained. Commitlog position was {}", writer.getFilename(), context); writer.abort(); ssTable = null; } if (heavilyContendedRowCount > 0) - logger.debug(String.format("High update contention in %d/%d partitions of %s ", heavilyContendedRowCount, rows.size(), Memtable.this.toString())); + logger.trace(String.format("High update contention in %d/%d partitions of %s ", heavilyContendedRowCount, rows.size(), Memtable.this.toString())); return ssTable; } diff --git a/src/java/org/apache/cassandra/db/MigrationRequestVerbHandler.java b/src/java/org/apache/cassandra/db/MigrationRequestVerbHandler.java index 79753c1295..ab934c604f 100644 --- a/src/java/org/apache/cassandra/db/MigrationRequestVerbHandler.java +++ b/src/java/org/apache/cassandra/db/MigrationRequestVerbHandler.java @@ -39,7 +39,7 @@ public class MigrationRequestVerbHandler implements IVerbHandler public void doVerb(MessageIn message, int id) { - logger.debug("Received migration request from {}.", message.from); + logger.trace("Received migration request from {}.", message.from); MessageOut> response = new MessageOut<>(MessagingService.Verb.INTERNAL_RESPONSE, LegacySchemaTables.convertSchemaToMutations(), MigrationManager.MigrationsSerializer.instance); diff --git a/src/java/org/apache/cassandra/db/SchemaCheckVerbHandler.java b/src/java/org/apache/cassandra/db/SchemaCheckVerbHandler.java index 1a1f7a9624..4270a247b0 100644 --- a/src/java/org/apache/cassandra/db/SchemaCheckVerbHandler.java +++ b/src/java/org/apache/cassandra/db/SchemaCheckVerbHandler.java @@ -35,7 +35,7 @@ public class SchemaCheckVerbHandler implements IVerbHandler public void doVerb(MessageIn message, int id) { - logger.debug("Received schema check request."); + logger.trace("Received schema check request."); MessageOut response = new MessageOut(MessagingService.Verb.INTERNAL_RESPONSE, Schema.instance.getVersion(), UUIDSerializer.serializer); MessagingService.instance().sendReply(response, id, message.from); } diff --git a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java index f054315019..8bf1ef3011 100644 --- a/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java +++ b/src/java/org/apache/cassandra/db/SizeEstimatesRecorder.java @@ -57,11 +57,11 @@ public class SizeEstimatesRecorder extends MigrationListener implements Runnable { if (StorageService.instance.isStarting()) { - logger.debug("Node has not yet joined; not recording size estimates"); + logger.trace("Node has not yet joined; not recording size estimates"); return; } - logger.debug("Recording size estimates"); + logger.trace("Recording size estimates"); // find primary token ranges for the local node. Collection localTokens = StorageService.instance.getLocalTokens(); @@ -74,7 +74,7 @@ public class SizeEstimatesRecorder extends MigrationListener implements Runnable long start = System.nanoTime(); recordSizeEstimates(table, localRanges); long passed = System.nanoTime() - start; - logger.debug("Spent {} milliseconds on estimating {}.{} size", + logger.trace("Spent {} milliseconds on estimating {}.{} size", TimeUnit.NANOSECONDS.toMillis(passed), table.metadata.ksName, table.metadata.cfName); diff --git a/src/java/org/apache/cassandra/db/SliceFromReadCommand.java b/src/java/org/apache/cassandra/db/SliceFromReadCommand.java index 461a3a196f..edace9d8fa 100644 --- a/src/java/org/apache/cassandra/db/SliceFromReadCommand.java +++ b/src/java/org/apache/cassandra/db/SliceFromReadCommand.java @@ -65,7 +65,7 @@ public class SliceFromReadCommand extends ReadCommand // reads in order to guarantee that the static columns are fetched. See CASSANDRA-8502 for more details. if (filter.reversed && filter.hasStaticSlice(cfm)) { - logger.debug("Splitting reversed slice with static columns into two reads"); + logger.trace("Splitting reversed slice with static columns into two reads"); Pair newFilters = filter.splitOutStaticSlice(cfm); Row normalResults = keyspace.getRow(new QueryFilter(dk, cfName, newFilters.right, timestamp)); diff --git a/src/java/org/apache/cassandra/db/SystemKeyspace.java b/src/java/org/apache/cassandra/db/SystemKeyspace.java index 18af90ff8d..308edcd863 100644 --- a/src/java/org/apache/cassandra/db/SystemKeyspace.java +++ b/src/java/org/apache/cassandra/db/SystemKeyspace.java @@ -1110,7 +1110,7 @@ public final class SystemKeyspace { if (dataDirectory.getName().equals("Versions") && dataDirectory.listFiles().length > 0) { - logger.debug("Found unreadable versions info in pre 1.2 system.Versions table"); + logger.trace("Found unreadable versions info in pre 1.2 system.Versions table"); return UNREADABLE_VERSION.toString(); } } diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLog.java b/src/java/org/apache/cassandra/db/commitlog/CommitLog.java index 0e08efeffc..a60c135e21 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLog.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLog.java @@ -303,7 +303,7 @@ public class CommitLog implements CommitLogMBean */ public void discardCompletedSegments(final UUID cfId, final ReplayPosition context) { - logger.debug("discard completed log segments for {}, table {}", context, cfId); + logger.trace("discard completed log segments for {}, table {}", context, cfId); // Go thru the active segment files, which are ordered oldest to newest, marking the // flushed CF as clean, until we reach the segment file containing the ReplayPosition passed @@ -316,12 +316,12 @@ public class CommitLog implements CommitLogMBean if (segment.isUnused()) { - logger.debug("Commit log segment {} is unused", segment); + logger.trace("Commit log segment {} is unused", segment); allocator.recycleSegment(segment); } else { - logger.debug("Not safe to delete{} commit log segment {}; dirty is {}", + logger.trace("Not safe to delete{} commit log segment {}; dirty is {}", (iter.hasNext() ? "" : " active"), segment, segment.dirtyString()); } diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogArchiver.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogArchiver.java index 4c615e0282..b7345733de 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogArchiver.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogArchiver.java @@ -83,7 +83,7 @@ public class CommitLogArchiver { if (stream == null) { - logger.debug("No commitlog_archiving properties found; archive + pitr will be disabled"); + logger.trace("No commitlog_archiving properties found; archive + pitr will be disabled"); return disabled(); } else @@ -237,7 +237,7 @@ public class CommitLogArchiver File toFile = new File(DatabaseDescriptor.getCommitLogLocation(), descriptor.fileName()); if (toFile.exists()) { - logger.debug("Skipping restore of archive {} as the segment already exists in the restore location {}", + logger.trace("Skipping restore of archive {} as the segment already exists in the restore location {}", fromFile.getPath(), toFile.getPath()); continue; } diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogReplayer.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogReplayer.java index 389b11190e..cb02a8c45b 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogReplayer.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogReplayer.java @@ -136,7 +136,7 @@ public class CommitLogReplayer cfPositions.put(cfs.metadata.cfId, rp); } ReplayPosition globalPosition = replayPositionOrdering.min(cfPositions.values()); - logger.debug("Global replay position is {} from columnfamilies {}", globalPosition, FBUtilities.toString(cfPositions)); + logger.trace("Global replay position is {} from columnfamilies {}", globalPosition, FBUtilities.toString(cfPositions)); return new CommitLogReplayer(commitLog, globalPosition, cfPositions, replayFilter); } @@ -154,7 +154,7 @@ public class CommitLogReplayer // wait for all the writes to finish on the mutation stage FBUtilities.waitOnFutures(futures); - logger.debug("Finished waiting on mutations from recovery"); + logger.trace("Finished waiting on mutations from recovery"); // flush replayed keyspaces futures.clear(); @@ -333,7 +333,7 @@ public class CommitLogReplayer { int replayPos = replayEnd + CommitLogSegment.SYNC_MARKER_SIZE; - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) logger.trace("Replaying {} between {} and {}", file, reader.getFilePointer(), end); if (compressor != null) { @@ -361,7 +361,7 @@ public class CommitLogReplayer try { int compressedLength = end - start; - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) logger.trace("Decompressing {} between replay positions {} and {}", file, replayPos, @@ -392,13 +392,13 @@ public class CommitLogReplayer finally { FileUtils.closeQuietly(reader); - logger.info("Finished reading {}", file); + logger.debug("Finished reading {}", file); } } public boolean logAndCheckIfShouldSkip(File file, CommitLogDescriptor desc) { - logger.info("Replaying {} (CL version {}, messaging version {}, compression {})", + logger.debug("Replaying {} (CL version {}, messaging version {}, compression {})", file.getPath(), desc.version, desc.getMessagingVersion(), @@ -406,7 +406,7 @@ public class CommitLogReplayer if (globalPosition.segment > desc.id) { - logger.debug("skipping replay of fully-flushed {}", file); + logger.trace("skipping replay of fully-flushed {}", file); return true; } return false; @@ -423,7 +423,7 @@ public class CommitLogReplayer while (reader.getFilePointer() < end && !reader.isEOF()) { long mutationStart = reader.getFilePointer(); - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) logger.trace("Reading mutation at {}", mutationStart); long claimedCRC32; @@ -434,7 +434,7 @@ public class CommitLogReplayer serializedSize = reader.readInt(); if (serializedSize == LEGACY_END_OF_SEGMENT_MARKER) { - logger.debug("Encountered end of segment marker at {}", reader.getFilePointer()); + logger.trace("Encountered end of segment marker at {}", reader.getFilePointer()); return false; } @@ -551,8 +551,8 @@ public class CommitLogReplayer return; } - if (logger.isDebugEnabled()) - logger.debug("replaying mutation for {}.{}: {}", mutation.getKeyspaceName(), ByteBufferUtil.bytesToHex(mutation.key()), "{" + StringUtils.join(mutation.getColumnFamilies().iterator(), ", ") + "}"); + if (logger.isTraceEnabled()) + logger.trace("replaying mutation for {}.{}: {}", mutation.getKeyspaceName(), ByteBufferUtil.bytesToHex(mutation.key()), "{" + StringUtils.join(mutation.getColumnFamilies().iterator(), ", ") + "}"); Runnable runnable = new WrappedRunnable() { diff --git a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentManager.java b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentManager.java index 591847489c..f71bb1b985 100644 --- a/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentManager.java +++ b/src/java/org/apache/cassandra/db/commitlog/CommitLogSegmentManager.java @@ -117,7 +117,7 @@ public class CommitLogSegmentManager // if we have no more work to do, check if we should create a new segment if (availableSegments.isEmpty() && (activeSegments.isEmpty() || createReserveSegments)) { - logger.debug("No segments in reserve; creating a fresh one"); + logger.trace("No segments in reserve; creating a fresh one"); // TODO : some error handling in case we fail to create a new segment availableSegments.add(CommitLogSegment.createSegment(commitLog)); hasAvailableSegments.signalAll(); @@ -354,7 +354,7 @@ public class CommitLogSegmentManager void recycleSegment(final File file) { // (don't decrease managed size, since this was never a "live" segment) - logger.debug("(Unopened) segment {} is no longer needed and will be deleted now", file); + logger.trace("(Unopened) segment {} is no longer needed and will be deleted now", file); FileUtils.deleteWithConfirm(file); } @@ -365,7 +365,7 @@ public class CommitLogSegmentManager */ private void discardSegment(final CommitLogSegment segment, final boolean deleteFile) { - logger.debug("Segment {} is no longer active and will be deleted {}", segment, deleteFile ? "now" : "by the archive script"); + logger.trace("Segment {} is no longer active and will be deleted {}", segment, deleteFile ? "now" : "by the archive script"); segmentManagementTasks.add(new Runnable() { @@ -397,7 +397,7 @@ public class CommitLogSegmentManager { long total = DatabaseDescriptor.getTotalCommitlogSpaceInMB() * 1024 * 1024; long currentSize = size.get(); - logger.debug("Total active commitlog segment space used is {} out of {}", currentSize, total); + logger.trace("Total active commitlog segment space used is {} out of {}", currentSize, total); return total - currentSize; } @@ -446,7 +446,7 @@ public class CommitLogSegmentManager { // even though we remove the schema entry before a final flush when dropping a CF, // it's still possible for a writer to race and finish his append after the flush. - logger.debug("Marking clean CF {} that doesn't exist anymore", dirtyCFId); + logger.trace("Marking clean CF {} that doesn't exist anymore", dirtyCFId); segment.markClean(dirtyCFId, segment.getContext()); } else if (!flushes.containsKey(dirtyCFId)) @@ -469,7 +469,7 @@ public class CommitLogSegmentManager */ public void stopUnsafe(boolean deleteSegments) { - logger.debug("CLSM closing and clearing existing commit log segments..."); + logger.trace("CLSM closing and clearing existing commit log segments..."); createReserveSegments = false; awaitManagementTasksCompletion(); @@ -498,7 +498,7 @@ public class CommitLogSegmentManager size.set(0L); - logger.debug("CLSM done with closing and clearing existing commit log segments."); + logger.trace("CLSM done with closing and clearing existing commit log segments."); } // Used by tests only. diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionController.java b/src/java/org/apache/cassandra/db/compaction/CompactionController.java index 81d8b7cff2..5f0a198689 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionController.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionController.java @@ -110,7 +110,7 @@ public class CompactionController implements AutoCloseable */ public static Set getFullyExpiredSSTables(ColumnFamilyStore cfStore, Iterable compacting, Iterable overlapping, int gcBefore) { - logger.debug("Checking droppable sstables in {}", cfStore); + logger.trace("Checking droppable sstables in {}", cfStore); if (compacting == null) return Collections.emptySet(); @@ -150,7 +150,7 @@ public class CompactionController implements AutoCloseable } else { - logger.debug("Dropping expired SSTable {} (maxLocalDeletionTime={}, gcBefore={})", + logger.trace("Dropping expired SSTable {} (maxLocalDeletionTime={}, gcBefore={})", candidate, candidate.getSSTableMetadata().maxLocalDeletionTime, gcBefore); } } diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java index 7def98dd35..ea20a1f782 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionManager.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionManager.java @@ -153,19 +153,19 @@ public class CompactionManager implements CompactionManagerMBean { if (cfs.isAutoCompactionDisabled()) { - logger.debug("Autocompaction is disabled"); + logger.trace("Autocompaction is disabled"); return Collections.emptyList(); } int count = compactingCF.count(cfs); if (count > 0 && executor.getActiveCount() >= executor.getMaximumPoolSize()) { - logger.debug("Background compaction is still running for {}.{} ({} remaining). Skipping", + logger.trace("Background compaction is still running for {}.{} ({} remaining). Skipping", cfs.keyspace.getName(), cfs.name, count); return Collections.emptyList(); } - logger.debug("Scheduling a background task check for {}.{} with {}", + logger.trace("Scheduling a background task check for {}.{} with {}", cfs.keyspace.getName(), cfs.name, cfs.getCompactionStrategy().getName()); @@ -211,10 +211,10 @@ public class CompactionManager implements CompactionManagerMBean { try { - logger.debug("Checking {}.{}", cfs.keyspace.getName(), cfs.name); + logger.trace("Checking {}.{}", cfs.keyspace.getName(), cfs.name); if (!cfs.isValid()) { - logger.debug("Aborting compaction for dropped CF"); + logger.trace("Aborting compaction for dropped CF"); return; } @@ -222,7 +222,7 @@ public class CompactionManager implements CompactionManagerMBean AbstractCompactionTask task = strategy.getNextBackgroundTask(getDefaultGcBefore(cfs)); if (task == null) { - logger.debug("No tasks available"); + logger.trace("No tasks available"); return; } task.execute(metrics); @@ -461,7 +461,7 @@ public class CompactionManager implements CompactionManagerMBean long repairedAt) throws InterruptedException, IOException { logger.info("Starting anticompaction for {}.{} on {}/{} sstables", cfs.keyspace.getName(), cfs.getColumnFamilyName(), validatedForRepair.size(), cfs.getSSTables().size()); - logger.debug("Starting anticompaction for ranges {}", ranges); + logger.trace("Starting anticompaction for ranges {}", ranges); Set sstables = new HashSet<>(validatedForRepair); Set mutatedRepairStatuses = new HashSet<>(); Set nonAnticompacting = new HashSet<>(); @@ -780,7 +780,7 @@ public class CompactionManager implements CompactionManagerMBean } if (!needsCleanup(sstable, ranges)) { - logger.debug("Skipping {} for cleanup; all rows should be kept", sstable); + logger.trace("Skipping {} for cleanup; all rows should be kept", sstable); return; } @@ -790,8 +790,8 @@ public class CompactionManager implements CompactionManagerMBean long expectedBloomFilterSize = Math.max(cfs.metadata.getMinIndexInterval(), SSTableReader.getApproximateKeyCount(txn.originals())); - if (logger.isDebugEnabled()) - logger.debug("Expected bloom filter size : {}", expectedBloomFilterSize); + if (logger.isTraceEnabled()) + logger.trace("Expected bloom filter size : {}", expectedBloomFilterSize); logger.info("Cleaning up {}", sstable); @@ -1110,11 +1110,11 @@ public class CompactionManager implements CompactionManagerMBean } } - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { // MT serialize may take time long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start); - logger.debug("Validation finished in {} msec, depth {} for {} keys, serialized size {} bytes for {}", + logger.trace("Validation finished in {} msec, depth {} for {} keys, serialized size {} bytes for {}", duration, depth, numPartitions, @@ -1243,7 +1243,7 @@ public class CompactionManager implements CompactionManagerMBean repairedSSTableWriter.commit(); unRepairedSSTableWriter.commit(); - logger.debug("Repaired {} keys out of {} for {}/{} in {}", repairedKeyCount, + logger.trace("Repaired {} keys out of {} for {}/{} in {}", repairedKeyCount, repairedKeyCount + unrepairedKeyCount, cfs.keyspace.getName(), cfs.getColumnFamilyName(), @@ -1295,7 +1295,7 @@ public class CompactionManager implements CompactionManagerMBean { if (!AutoSavingCache.flushInProgress.add(writer.cacheType())) { - logger.debug("Cache flushing was already in progress: skipping {}", writer.getCompactionInfo()); + logger.trace("Cache flushing was already in progress: skipping {}", writer.getCompactionInfo()); return; } try @@ -1417,7 +1417,7 @@ public class CompactionManager implements CompactionManagerMBean if (t.getSuppressed() != null && t.getSuppressed().length > 0) logger.warn("Interruption of compaction encountered exceptions:", t); else - logger.debug("Full interruption stack trace:", t); + logger.trace("Full interruption stack trace:", t); } else { diff --git a/src/java/org/apache/cassandra/db/compaction/CompactionTask.java b/src/java/org/apache/cassandra/db/compaction/CompactionTask.java index ea64fb2f84..575c3261f8 100644 --- a/src/java/org/apache/cassandra/db/compaction/CompactionTask.java +++ b/src/java/org/apache/cassandra/db/compaction/CompactionTask.java @@ -139,7 +139,7 @@ public class CompactionTask extends AbstractCompactionTask } ssTableLoggerMsg.append("]"); String taskIdLoggerMsg = taskId == null ? UUIDGen.getTimeUUID().toString() : taskId.toString(); - logger.info("Compacting ({}) {}", taskIdLoggerMsg, ssTableLoggerMsg); + logger.debug("Compacting ({}) {}", taskIdLoggerMsg, ssTableLoggerMsg); long start = System.nanoTime(); @@ -221,10 +221,10 @@ public class CompactionTask extends AbstractCompactionTask double mbps = dTime > 0 ? (double) endsize / (1024 * 1024) / ((double) dTime / 1000) : 0; long totalSourceRows = 0; String mergeSummary = updateCompactionHistory(cfs.keyspace.getName(), cfs.getColumnFamilyName(), ci, startsize, endsize); - logger.info(String.format("Compacted (%s) %d sstables to [%s] to level=%d. %,d bytes to %,d (~%d%% of original) in %,dms = %fMB/s. %,d total partitions merged to %,d. Partition merge counts were {%s}", + logger.debug(String.format("Compacted (%s) %d sstables to [%s] to level=%d. %,d bytes to %,d (~%d%% of original) in %,dms = %fMB/s. %,d total partitions merged to %,d. Partition merge counts were {%s}", taskIdLoggerMsg, transaction.originals().size(), newSSTableNames.toString(), getLevel(), startsize, endsize, (int) (ratio * 100), dTime, mbps, totalSourceRows, totalKeysWritten, mergeSummary)); - logger.debug(String.format("CF Total Bytes Compacted: %,d", CompactionTask.addToTotalBytesCompacted(endsize))); - logger.debug("Actual #keys: {}, Estimated #keys:{}, Err%: {}", totalKeysWritten, estimatedKeys, ((double)(totalKeysWritten - estimatedKeys)/totalKeysWritten)); + logger.trace(String.format("CF Total Bytes Compacted: %,d", CompactionTask.addToTotalBytesCompacted(endsize))); + logger.trace("Actual #keys: {}, Estimated #keys:{}, Err%: {}", totalKeysWritten, estimatedKeys, ((double)(totalKeysWritten - estimatedKeys)/totalKeysWritten)); if (offline) Refs.release(Refs.selfRefs(newSStables)); diff --git a/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java index 095696216f..da2d35d7d9 100644 --- a/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/DateTieredCompactionStrategy.java @@ -50,10 +50,10 @@ public class DateTieredCompactionStrategy extends AbstractCompactionStrategy if (!options.containsKey(AbstractCompactionStrategy.TOMBSTONE_COMPACTION_INTERVAL_OPTION) && !options.containsKey(AbstractCompactionStrategy.TOMBSTONE_THRESHOLD_OPTION)) { disableTombstoneCompactions = true; - logger.debug("Disabling tombstone compactions for DTCS"); + logger.trace("Disabling tombstone compactions for DTCS"); } else - logger.debug("Enabling tombstone compactions for DTCS"); + logger.trace("Enabling tombstone compactions for DTCS"); } @@ -99,7 +99,7 @@ public class DateTieredCompactionStrategy extends AbstractCompactionStrategy List compactionCandidates = new ArrayList<>(getNextNonExpiredSSTables(Sets.difference(candidates, expired), gcBefore)); if (!expired.isEmpty()) { - logger.debug("Including expired sstables: {}", expired); + logger.trace("Including expired sstables: {}", expired); compactionCandidates.addAll(expired); } return compactionCandidates; @@ -134,7 +134,7 @@ public class DateTieredCompactionStrategy extends AbstractCompactionStrategy Iterable candidates = filterOldSSTables(Lists.newArrayList(candidateSSTables), options.maxSSTableAge, now); List> buckets = getBuckets(createSSTableAndMinTimestampPairs(candidates), options.baseTime, base, now); - logger.debug("Compaction buckets are {}", buckets); + logger.trace("Compaction buckets are {}", buckets); updateEstimatedCompactionsByTasks(buckets); List mostInteresting = newestBucket(buckets, cfs.getMinimumCompactionThreshold(), @@ -391,7 +391,7 @@ public class DateTieredCompactionStrategy extends AbstractCompactionStrategy LifecycleTransaction modifier = cfs.getTracker().tryModify(sstables, OperationType.COMPACTION); if (modifier == null) { - logger.debug("Unable to mark {} for compaction; probably a background compaction got to it first. You can disable background compactions temporarily if this is a problem", sstables); + logger.trace("Unable to mark {} for compaction; probably a background compaction got to it first. You can disable background compactions temporarily if this is a problem", sstables); return null; } diff --git a/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java index 9a88164ea1..ddbc3a19ce 100644 --- a/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/LeveledCompactionStrategy.java @@ -71,7 +71,7 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy maxSSTableSizeInMB = configuredMaxSSTableSize; manifest = new LeveledManifest(cfs, this.maxSSTableSizeInMB, localOptions); - logger.debug("Created {}", manifest); + logger.trace("Created {}", manifest); } public int getLevelSize(int i) @@ -101,7 +101,7 @@ public class LeveledCompactionStrategy extends AbstractCompactionStrategy SSTableReader sstable = findDroppableSSTable(gcBefore); if (sstable == null) { - logger.debug("No compaction necessary for {}", this); + logger.trace("No compaction necessary for {}", this); return null; } candidate = new LeveledManifest.CompactionCandidate(Collections.singleton(sstable), diff --git a/src/java/org/apache/cassandra/db/compaction/LeveledManifest.java b/src/java/org/apache/cassandra/db/compaction/LeveledManifest.java index 0d0928f777..d90318f791 100644 --- a/src/java/org/apache/cassandra/db/compaction/LeveledManifest.java +++ b/src/java/org/apache/cassandra/db/compaction/LeveledManifest.java @@ -115,7 +115,7 @@ public class LeveledManifest if (canAddSSTable(reader)) { // adding the sstable does not cause overlap in the level - logger.debug("Adding {} to L{}", reader, level); + logger.trace("Adding {} to L{}", reader, level); generations[level].add(reader); } else @@ -146,8 +146,8 @@ public class LeveledManifest { assert !removed.isEmpty(); // use add() instead of promote when adding new sstables logDistribution(); - if (logger.isDebugEnabled()) - logger.debug("Replacing [{}]", toString(removed)); + if (logger.isTraceEnabled()) + logger.trace("Replacing [{}]", toString(removed)); // the level for the added sstables is the max of the removed ones, // plus one if the removed were all on the same level @@ -163,8 +163,8 @@ public class LeveledManifest if (added.isEmpty()) return; - if (logger.isDebugEnabled()) - logger.debug("Adding [{}]", toString(added)); + if (logger.isTraceEnabled()) + logger.trace("Adding [{}]", toString(added)); for (SSTableReader ssTableReader : added) add(ssTableReader); @@ -317,7 +317,7 @@ public class LeveledManifest Set sstablesInLevel = Sets.newHashSet(sstables); Set remaining = Sets.difference(sstablesInLevel, cfs.getTracker().getCompacting()); double score = (double) SSTableReader.getTotalBytes(remaining) / (double)maxBytesForLevel(i, maxSSTableSizeInBytes); - logger.debug("Compaction score for level {} is {}", i, score); + logger.trace("Compaction score for level {} is {}", i, score); if (score > 1.001) { @@ -327,7 +327,7 @@ public class LeveledManifest List mostInteresting = getSSTablesForSTCS(getLevel(0)); if (!mostInteresting.isEmpty()) { - logger.debug("L0 is too far behind, performing size-tiering there first"); + logger.trace("L0 is too far behind, performing size-tiering there first"); return new CompactionCandidate(mostInteresting, 0, Long.MAX_VALUE); } } @@ -338,13 +338,13 @@ public class LeveledManifest { int nextLevel = getNextLevel(candidates); candidates = getOverlappingStarvedSSTables(nextLevel, candidates); - if (logger.isDebugEnabled()) - logger.debug("Compaction candidates for L{} are {}", i, toString(candidates)); + if (logger.isTraceEnabled()) + logger.trace("Compaction candidates for L{} are {}", i, toString(candidates)); return new CompactionCandidate(candidates, nextLevel, cfs.getCompactionStrategy().getMaxSSTableBytes()); } else { - logger.debug("No compaction candidates for L{}", i); + logger.trace("No compaction candidates for L{}", i); } } } @@ -387,10 +387,10 @@ public class LeveledManifest for (int i = generations.length - 1; i > 0; i--) compactionCounter[i]++; compactionCounter[targetLevel] = 0; - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { for (int j = 0; j < compactionCounter.length; j++) - logger.debug("CompactionCounter: {}: {}", j, compactionCounter[j]); + logger.trace("CompactionCounter: {}: {}", j, compactionCounter[j]); } for (int i = generations.length - 1; i > 0; i--) @@ -451,13 +451,13 @@ public class LeveledManifest private void logDistribution() { - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { for (int i = 0; i < generations.length; i++) { if (!getLevel(i).isEmpty()) { - logger.debug("L{} contains {} SSTables ({} bytes) in {}", + logger.trace("L{} contains {} SSTables ({} bytes) in {}", i, getLevel(i).size(), SSTableReader.getTotalBytes(getLevel(i)), this); } } @@ -539,7 +539,7 @@ public class LeveledManifest private Collection getCandidatesFor(int level) { assert !getLevel(level).isEmpty(); - logger.debug("Choosing candidates for L{}", level); + logger.trace("Choosing candidates for L{}", level); final Set compacting = cfs.getTracker().getCompacting(); @@ -703,7 +703,7 @@ public class LeveledManifest tasks += estimated[i]; } - logger.debug("Estimating {} compactions to do for {}.{}", + logger.trace("Estimating {} compactions to do for {}.{}", Arrays.toString(estimated), cfs.keyspace.getName(), cfs.name); return Ints.checkedCast(tasks); } diff --git a/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java index 4ba2378304..b4125bbbd5 100644 --- a/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/SizeTieredCompactionStrategy.java @@ -82,7 +82,7 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy Iterable candidates = filterSuspectSSTables(Sets.intersection(cfs.getUncompactingSSTables(), sstables)); List> buckets = getBuckets(createSSTableAndLengthPairs(candidates), sizeTieredOptions.bucketHigh, sizeTieredOptions.bucketLow, sizeTieredOptions.minSSTableSize); - logger.debug("Compaction buckets are {}", buckets); + logger.trace("Compaction buckets are {}", buckets); updateEstimatedCompactionsByTasks(buckets); List mostInteresting = mostInterestingBucket(buckets, minThreshold, maxThreshold); if (!mostInteresting.isEmpty()) @@ -210,7 +210,7 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy LifecycleTransaction transaction = cfs.getTracker().tryModify(sstables, OperationType.COMPACTION); if (transaction == null) { - logger.debug("Unable to mark {} for compaction; probably a background compaction got to it first. You can disable background compactions temporarily if this is a problem", sstables); + logger.trace("Unable to mark {} for compaction; probably a background compaction got to it first. You can disable background compactions temporarily if this is a problem", sstables); return null; } diff --git a/src/java/org/apache/cassandra/db/compaction/WrappingCompactionStrategy.java b/src/java/org/apache/cassandra/db/compaction/WrappingCompactionStrategy.java index 1e73daf978..9daa0c5f6c 100644 --- a/src/java/org/apache/cassandra/db/compaction/WrappingCompactionStrategy.java +++ b/src/java/org/apache/cassandra/db/compaction/WrappingCompactionStrategy.java @@ -63,7 +63,7 @@ public final class WrappingCompactionStrategy extends AbstractCompactionStrategy super(cfs, cfs.metadata.compactionStrategyOptions); reloadCompactionStrategy(cfs.metadata); cfs.getTracker().subscribe(this); - logger.debug("{} subscribed to the data tracker.", this); + logger.trace("{} subscribed to the data tracker.", this); } @Override diff --git a/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java b/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java index 7d88458206..6611b3f62b 100644 --- a/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/writers/DefaultCompactionWriter.java @@ -45,7 +45,7 @@ public class DefaultCompactionWriter extends CompactionAwareWriter public DefaultCompactionWriter(ColumnFamilyStore cfs, LifecycleTransaction txn, Set nonExpiredSSTables, boolean offline, OperationType compactionType) { super(cfs, txn, nonExpiredSSTables, offline); - logger.debug("Expected bloom filter size : {}", estimatedTotalKeys); + logger.trace("Expected bloom filter size : {}", estimatedTotalKeys); long expectedWriteSize = cfs.getExpectedCompactedFileSize(nonExpiredSSTables, compactionType); File sstableDirectory = cfs.directories.getLocationForDisk(getWriteDirectory(expectedWriteSize)); @SuppressWarnings("resource") diff --git a/src/java/org/apache/cassandra/db/compaction/writers/SplittingSizeTieredCompactionWriter.java b/src/java/org/apache/cassandra/db/compaction/writers/SplittingSizeTieredCompactionWriter.java index 9ff1325b49..ed07df9bcc 100644 --- a/src/java/org/apache/cassandra/db/compaction/writers/SplittingSizeTieredCompactionWriter.java +++ b/src/java/org/apache/cassandra/db/compaction/writers/SplittingSizeTieredCompactionWriter.java @@ -93,7 +93,7 @@ public class SplittingSizeTieredCompactionWriter extends CompactionAwareWriter new MetadataCollector(allSSTables, cfs.metadata.comparator, 0)); sstableWriter.switchWriter(writer); - logger.debug("Ratios={}, expectedKeys = {}, totalSize = {}, currentPartitionsToWrite = {}, currentBytesToWrite = {}", ratios, estimatedTotalKeys, totalSize, currentPartitionsToWrite, currentBytesToWrite); + logger.trace("Ratios={}, expectedKeys = {}, totalSize = {}, currentPartitionsToWrite = {}, currentBytesToWrite = {}", ratios, estimatedTotalKeys, totalSize, currentPartitionsToWrite, currentBytesToWrite); } @Override @@ -114,7 +114,7 @@ public class SplittingSizeTieredCompactionWriter extends CompactionAwareWriter cfs.partitioner, new MetadataCollector(allSSTables, cfs.metadata.comparator, 0)); sstableWriter.switchWriter(writer); - logger.debug("Switching writer, currentPartitionsToWrite = {}", currentPartitionsToWrite); + logger.trace("Switching writer, currentPartitionsToWrite = {}", currentPartitionsToWrite); } return rie != null; } diff --git a/src/java/org/apache/cassandra/db/filter/ExtendedFilter.java b/src/java/org/apache/cassandra/db/filter/ExtendedFilter.java index 50ab57dfb2..c6d93fe1aa 100644 --- a/src/java/org/apache/cassandra/db/filter/ExtendedFilter.java +++ b/src/java/org/apache/cassandra/db/filter/ExtendedFilter.java @@ -261,7 +261,7 @@ public abstract class ExtendedFilter { if (data.getColumn(data.getComparator().cellFromByteBuffer(expr.column)) == null) { - logger.debug("adding extraFilter to cover additional expressions"); + logger.trace("adding extraFilter to cover additional expressions"); return true; } } diff --git a/src/java/org/apache/cassandra/db/index/AbstractSimplePerColumnSecondaryIndex.java b/src/java/org/apache/cassandra/db/index/AbstractSimplePerColumnSecondaryIndex.java index ba48350806..854d6883c8 100644 --- a/src/java/org/apache/cassandra/db/index/AbstractSimplePerColumnSecondaryIndex.java +++ b/src/java/org/apache/cassandra/db/index/AbstractSimplePerColumnSecondaryIndex.java @@ -101,8 +101,8 @@ public abstract class AbstractSimplePerColumnSecondaryIndex extends PerColumnSec ColumnFamily cfi = ArrayBackedSortedColumns.factory.create(indexCfs.metadata, false, 1); cfi.addTombstone(makeIndexColumnName(rowKey, cell), localDeletionTime, cell.timestamp()); indexCfs.apply(valueKey, cfi, SecondaryIndexManager.nullUpdater, opGroup, null); - if (logger.isDebugEnabled()) - logger.debug("removed index entry for cleaned-up value {}:{}", valueKey, cfi); + if (logger.isTraceEnabled()) + logger.trace("removed index entry for cleaned-up value {}:{}", valueKey, cfi); } public void insert(ByteBuffer rowKey, Cell cell, OpOrder.Group opGroup) @@ -119,8 +119,8 @@ public abstract class AbstractSimplePerColumnSecondaryIndex extends PerColumnSec { cfi.addColumn(new BufferCell(name, ByteBufferUtil.EMPTY_BYTE_BUFFER, cell.timestamp())); } - if (logger.isDebugEnabled()) - logger.debug("applying index row {} in {}", indexCfs.metadata.getKeyValidator().getString(valueKey.getKey()), cfi); + if (logger.isTraceEnabled()) + logger.trace("applying index row {} in {}", indexCfs.metadata.getKeyValidator().getString(valueKey.getKey()), cfi); indexCfs.apply(valueKey, cfi, SecondaryIndexManager.nullUpdater, opGroup, null); } diff --git a/src/java/org/apache/cassandra/db/index/composites/CompositesIndex.java b/src/java/org/apache/cassandra/db/index/composites/CompositesIndex.java index e88d456560..0be78ccfdf 100644 --- a/src/java/org/apache/cassandra/db/index/composites/CompositesIndex.java +++ b/src/java/org/apache/cassandra/db/index/composites/CompositesIndex.java @@ -142,8 +142,8 @@ public abstract class CompositesIndex extends AbstractSimplePerColumnSecondaryIn ColumnFamily cfi = ArrayBackedSortedColumns.factory.create(indexCfs.metadata); cfi.addTombstone(entry.indexEntry, localDeletionTime, entry.timestamp); indexCfs.apply(entry.indexValue, cfi, SecondaryIndexManager.nullUpdater, opGroup, null); - if (logger.isDebugEnabled()) - logger.debug("removed index entry for cleaned-up value {}:{}", entry.indexValue, cfi); + if (logger.isTraceEnabled()) + logger.trace("removed index entry for cleaned-up value {}:{}", entry.indexValue, cfi); } protected AbstractType getExpressionComparator() diff --git a/src/java/org/apache/cassandra/db/index/composites/CompositesSearcher.java b/src/java/org/apache/cassandra/db/index/composites/CompositesSearcher.java index 88453df873..2f85e35f77 100644 --- a/src/java/org/apache/cassandra/db/index/composites/CompositesSearcher.java +++ b/src/java/org/apache/cassandra/db/index/composites/CompositesSearcher.java @@ -98,8 +98,8 @@ public class CompositesSearcher extends SecondaryIndexSearcher assert index.getIndexCfs() != null; final DecoratedKey indexKey = index.getIndexKeyFor(primary.value); - if (logger.isDebugEnabled()) - logger.debug("Most-selective indexed predicate is {}", index.expressionString(primary)); + if (logger.isTraceEnabled()) + logger.trace("Most-selective indexed predicate is {}", index.expressionString(primary)); /* * XXX: If the range requested is a token range, we'll have to start at the beginning (and stop at the end) of @@ -240,7 +240,7 @@ public class CompositesSearcher extends SecondaryIndexSearcher } else { - logger.debug("Skipping entry {} before assigned scan range", dk.getToken()); + logger.trace("Skipping entry {} before assigned scan range", dk.getToken()); continue; } } diff --git a/src/java/org/apache/cassandra/db/index/keys/KeysSearcher.java b/src/java/org/apache/cassandra/db/index/keys/KeysSearcher.java index b4fd0bae55..2f0420f5f3 100644 --- a/src/java/org/apache/cassandra/db/index/keys/KeysSearcher.java +++ b/src/java/org/apache/cassandra/db/index/keys/KeysSearcher.java @@ -73,8 +73,8 @@ public class KeysSearcher extends SecondaryIndexSearcher assert index.getIndexCfs() != null; final DecoratedKey indexKey = index.getIndexKeyFor(primary.value); - if (logger.isDebugEnabled()) - logger.debug("Most-selective indexed predicate is {}", + if (logger.isTraceEnabled()) + logger.trace("Most-selective indexed predicate is {}", ((AbstractSimplePerColumnSecondaryIndex) index).expressionString(primary)); /* diff --git a/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java b/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java index dfa30c7583..9b522693fc 100644 --- a/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java +++ b/src/java/org/apache/cassandra/db/lifecycle/LifecycleTransaction.java @@ -150,7 +150,7 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional { assert staged.isEmpty() : "must be no actions introduced between prepareToCommit and a commit"; - logger.debug("Committing update:{}, obsolete:{}", staged.update, staged.obsolete); + logger.trace("Committing update:{}, obsolete:{}", staged.update, staged.obsolete); // this is now the point of no return; we cannot safely rollback, so we ignore exceptions until we're done // we restore state by obsoleting our obsolete files, releasing our references to them, and updating our size @@ -167,15 +167,15 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional */ public Throwable doAbort(Throwable accumulate) { - if (logger.isDebugEnabled()) - logger.debug("Aborting transaction over {}, with ({},{}) logged and ({},{}) staged", originals, logged.update, logged.obsolete, staged.update, staged.obsolete); + if (logger.isTraceEnabled()) + logger.trace("Aborting transaction over {}, with ({},{}) logged and ({},{}) staged", originals, logged.update, logged.obsolete, staged.update, staged.obsolete); if (logged.isEmpty() && staged.isEmpty()) return accumulate; // mark obsolete all readers that are not versions of those present in the original set Iterable obsolete = filterOut(concatUniq(staged.update, logged.update), originals); - logger.debug("Obsoleting {}", obsolete); + logger.trace("Obsoleting {}", obsolete); // we don't pass the tracker in for the obsoletion, since these readers have never been notified externally // nor had their size accounting affected accumulate = markObsolete(null, obsolete, accumulate); @@ -221,8 +221,8 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional } private Throwable checkpoint(Throwable accumulate) { - if (logger.isDebugEnabled()) - logger.debug("Checkpointing update:{}, obsolete:{}", staged.update, staged.obsolete); + if (logger.isTraceEnabled()) + logger.trace("Checkpointing update:{}, obsolete:{}", staged.update, staged.obsolete); if (staged.isEmpty()) return accumulate; @@ -275,7 +275,7 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional */ public void obsolete(SSTableReader reader) { - logger.debug("Staging for obsolescence {}", reader); + logger.trace("Staging for obsolescence {}", reader); // check this is: a reader guarded by the transaction, an instance we have already worked with // and that we haven't already obsoleted it, nor do we have other changes staged for it assert identities.contains(reader.instanceId) : "only reader instances that have previously been provided may be obsoleted: " + reader; @@ -291,7 +291,7 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional */ public void obsoleteOriginals() { - logger.debug("Staging for obsolescence {}", originals); + logger.trace("Staging for obsolescence {}", originals); // if we're obsoleting, we should have no staged updates for the original files assert Iterables.isEmpty(filterIn(staged.update, originals)) : staged.update; @@ -381,7 +381,7 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional */ public void cancel(SSTableReader cancel) { - logger.debug("Cancelling {} from transaction", cancel); + logger.trace("Cancelling {} from transaction", cancel); assert originals.contains(cancel) : "may only cancel a reader in the 'original' set: " + cancel + " vs " + originals; assert !(staged.contains(cancel) || logged.contains(cancel)) : "may only cancel a reader that has not been updated or obsoleted in this transaction: " + cancel; originals.remove(cancel); @@ -405,7 +405,7 @@ public class LifecycleTransaction extends Transactional.AbstractTransactional */ public LifecycleTransaction split(Collection readers) { - logger.debug("Splitting {} into new transaction", readers); + logger.trace("Splitting {} into new transaction", readers); checkUnused(); for (SSTableReader reader : readers) assert identities.contains(reader.instanceId) : "may only split the same reader instance the transaction was opened with: " + reader; diff --git a/src/java/org/apache/cassandra/db/lifecycle/Tracker.java b/src/java/org/apache/cassandra/db/lifecycle/Tracker.java index f1c4685763..a074216584 100644 --- a/src/java/org/apache/cassandra/db/lifecycle/Tracker.java +++ b/src/java/org/apache/cassandra/db/lifecycle/Tracker.java @@ -137,8 +137,8 @@ public class Tracker long add = 0; for (SSTableReader sstable : newSSTables) { - if (logger.isDebugEnabled()) - logger.debug("adding {} to list of files tracked for {}.{}", sstable.descriptor, cfstore.keyspace.getName(), cfstore.name); + if (logger.isTraceEnabled()) + logger.trace("adding {} to list of files tracked for {}.{}", sstable.descriptor, cfstore.keyspace.getName(), cfstore.name); try { add += sstable.bytesOnDisk(); @@ -151,8 +151,8 @@ public class Tracker long subtract = 0; for (SSTableReader sstable : oldSSTables) { - if (logger.isDebugEnabled()) - logger.debug("removing {} from list of files tracked for {}.{}", sstable.descriptor, cfstore.keyspace.getName(), cfstore.name); + if (logger.isTraceEnabled()) + logger.trace("removing {} from list of files tracked for {}.{}", sstable.descriptor, cfstore.keyspace.getName(), cfstore.name); try { subtract += sstable.bytesOnDisk(); diff --git a/src/java/org/apache/cassandra/dht/BootStrapper.java b/src/java/org/apache/cassandra/dht/BootStrapper.java index aca05f0d00..a6b1ad7237 100644 --- a/src/java/org/apache/cassandra/dht/BootStrapper.java +++ b/src/java/org/apache/cassandra/dht/BootStrapper.java @@ -65,7 +65,7 @@ public class BootStrapper extends ProgressEventNotifierSupport public ListenableFuture bootstrap(StreamStateStore stateStore, boolean useStrictConsistency) { - logger.debug("Beginning bootstrap process"); + logger.trace("Beginning bootstrap process"); RangeStreamer streamer = new RangeStreamer(tokenMetadata, tokens, @@ -159,7 +159,7 @@ public class BootStrapper extends ProgressEventNotifierSupport // if user specified tokens, use those if (initialTokens.size() > 0) { - logger.debug("tokens manually specified as {}", initialTokens); + logger.trace("tokens manually specified as {}", initialTokens); List tokens = new ArrayList<>(initialTokens.size()); for (String tokenString : initialTokens) { diff --git a/src/java/org/apache/cassandra/dht/RangeStreamer.java b/src/java/org/apache/cassandra/dht/RangeStreamer.java index 68c8a11038..8f2dc12a4e 100644 --- a/src/java/org/apache/cassandra/dht/RangeStreamer.java +++ b/src/java/org/apache/cassandra/dht/RangeStreamer.java @@ -146,18 +146,18 @@ public class RangeStreamer Multimap, InetAddress> rangesForKeyspace = useStrictSourcesForRanges(keyspaceName) ? getAllRangesWithStrictSourcesFor(keyspaceName, ranges) : getAllRangesWithSourcesFor(keyspaceName, ranges); - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { for (Map.Entry, InetAddress> entry : rangesForKeyspace.entries()) - logger.debug(String.format("%s: range %s exists on %s", description, entry.getKey(), entry.getValue())); + logger.trace(String.format("%s: range %s exists on %s", description, entry.getKey(), entry.getValue())); } for (Map.Entry>> entry : getRangeFetchMap(rangesForKeyspace, sourceFilters, keyspaceName).asMap().entrySet()) { - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { for (Range r : entry.getValue()) - logger.debug(String.format("%s: range %s from source %s for keyspace %s", description, r, entry.getKey(), keyspaceName)); + logger.trace(String.format("%s: range %s from source %s for keyspace %s", description, r, entry.getKey(), keyspaceName)); } toFetch.put(keyspaceName, entry); } @@ -339,8 +339,8 @@ public class RangeStreamer logger.info("Some ranges of {} are already available. Skipping streaming those ranges.", availableRanges); } - if (logger.isDebugEnabled()) - logger.debug("{}ing from {} ranges {}", description, source, StringUtils.join(ranges, ", ")); + if (logger.isTraceEnabled()) + logger.trace("{}ing from {} ranges {}", description, source, StringUtils.join(ranges, ", ")); /* Send messages to respective folks to stream data over to me */ streamPlan.requestRanges(source, preferred, keyspace, ranges); } diff --git a/src/java/org/apache/cassandra/hadoop/AbstractColumnFamilyInputFormat.java b/src/java/org/apache/cassandra/hadoop/AbstractColumnFamilyInputFormat.java index 9c45bfeff5..103d4788b5 100644 --- a/src/java/org/apache/cassandra/hadoop/AbstractColumnFamilyInputFormat.java +++ b/src/java/org/apache/cassandra/hadoop/AbstractColumnFamilyInputFormat.java @@ -81,7 +81,7 @@ public abstract class AbstractColumnFamilyInputFormat extends InputFormat< keyspace = ConfigHelper.getInputKeyspace(conf); cfName = ConfigHelper.getInputColumnFamily(conf); partitioner = ConfigHelper.getInputPartitioner(conf); - logger.debug("partitioner is {}", partitioner); + logger.trace("partitioner is {}", partitioner); // canonical ranges and nodes holding replicas Map> masterRangeNodes = getRangeMap(conf, keyspace); @@ -219,7 +219,7 @@ public abstract class AbstractColumnFamilyInputFormat extends InputFormat< subSplits.get(subSplit), endpoints); - logger.debug("adding {}", split); + logger.trace("adding {}", split); splits.add(split); } } diff --git a/src/java/org/apache/cassandra/hadoop/ColumnFamilyInputFormat.java b/src/java/org/apache/cassandra/hadoop/ColumnFamilyInputFormat.java index 4662fa509f..87cb791ee0 100644 --- a/src/java/org/apache/cassandra/hadoop/ColumnFamilyInputFormat.java +++ b/src/java/org/apache/cassandra/hadoop/ColumnFamilyInputFormat.java @@ -63,7 +63,7 @@ public class ColumnFamilyInputFormat extends AbstractColumnFamilyInputFormat if (StringUtils.isEmpty(cqlQuery)) cqlQuery = buildQuery(); - logger.debug("cqlQuery {}", cqlQuery); + logger.trace("cqlQuery {}", cqlQuery); rowIterator = new RowIterator(); - logger.debug("created {}", rowIterator); + logger.trace("created {}", rowIterator); } public void close() @@ -194,7 +194,7 @@ public class CqlRecordReader extends RecordReader { if (!rowIterator.hasNext()) { - logger.debug("Finished scanning {} rows (estimate was: {})", rowIterator.totalRead, totalRowCount); + logger.trace("Finished scanning {} rows (estimate was: {})", rowIterator.totalRead, totalRowCount); return false; } diff --git a/src/java/org/apache/cassandra/hadoop/cql3/LimitedLocalNodeFirstLocalBalancingPolicy.java b/src/java/org/apache/cassandra/hadoop/cql3/LimitedLocalNodeFirstLocalBalancingPolicy.java index da0822ac80..5c8d3c59a4 100644 --- a/src/java/org/apache/cassandra/hadoop/cql3/LimitedLocalNodeFirstLocalBalancingPolicy.java +++ b/src/java/org/apache/cassandra/hadoop/cql3/LimitedLocalNodeFirstLocalBalancingPolicy.java @@ -71,7 +71,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy logger.warn("Invalid replica host name: {}, skipping it", replica); } } - logger.debug("Created instance with the following replicas: {}", Arrays.asList(replicas)); + logger.trace("Created instance with the following replicas: {}", Arrays.asList(replicas)); } @Override @@ -86,7 +86,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy } } liveReplicaHosts.addAll(replicaHosts); - logger.debug("Initialized with replica hosts: {}", replicaHosts); + logger.trace("Initialized with replica hosts: {}", replicaHosts); } @Override @@ -127,7 +127,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy Collections.shuffle(remote); - logger.debug("Using the following hosts order for the new query plan: {} | {}", local, remote); + logger.trace("Using the following hosts order for the new query plan: {} | {}", local, remote); return Iterators.concat(local.iterator(), remote.iterator()); } @@ -138,7 +138,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy if (replicaAddresses.contains(host.getAddress())) { liveReplicaHosts.add(host); - logger.debug("Added a new host {}", host); + logger.trace("Added a new host {}", host); } } @@ -148,7 +148,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy if (replicaAddresses.contains(host.getAddress())) { liveReplicaHosts.add(host); - logger.debug("The host {} is now up", host); + logger.trace("The host {} is now up", host); } } @@ -157,7 +157,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy { if (liveReplicaHosts.remove(host)) { - logger.debug("The host {} is now down", host); + logger.trace("The host {} is now down", host); } } @@ -167,7 +167,7 @@ class LimitedLocalNodeFirstLocalBalancingPolicy implements LoadBalancingPolicy { if (liveReplicaHosts.remove(host)) { - logger.debug("Removed the host {}", host); + logger.trace("Removed the host {}", host); } } diff --git a/src/java/org/apache/cassandra/hadoop/pig/CassandraStorage.java b/src/java/org/apache/cassandra/hadoop/pig/CassandraStorage.java index 5d354a798f..71fe037c5d 100644 --- a/src/java/org/apache/cassandra/hadoop/pig/CassandraStorage.java +++ b/src/java/org/apache/cassandra/hadoop/pig/CassandraStorage.java @@ -1028,7 +1028,7 @@ public class CassandraStorage extends LoadFunc implements StoreFuncInterface, Lo ColumnDef cDef = new ColumnDef(); String columnName = def.name.toString(); String type = def.type.toString(); - logger.debug("name: {}, type: {} ", columnName, type); + logger.trace("name: {}, type: {} ", columnName, type); cDef.name = ByteBufferUtil.bytes(columnName); cDef.validation_class = type; columnDefs.add(cDef); diff --git a/src/java/org/apache/cassandra/hadoop/pig/CqlNativeStorage.java b/src/java/org/apache/cassandra/hadoop/pig/CqlNativeStorage.java index 223a848b1a..bdf99a0907 100644 --- a/src/java/org/apache/cassandra/hadoop/pig/CqlNativeStorage.java +++ b/src/java/org/apache/cassandra/hadoop/pig/CqlNativeStorage.java @@ -626,7 +626,7 @@ public class CqlNativeStorage extends LoadFunc implements StoreFuncInterface, Lo if (wc != null) { - logger.debug("where clause: {}", wc); + logger.trace("where clause: {}", wc); CqlConfigHelper.setInputWhereClauses(conf, wc); } if (System.getenv(StorageHelper.PIG_INPUT_SPLIT_SIZE) != null) diff --git a/src/java/org/apache/cassandra/io/sstable/IndexSummaryManager.java b/src/java/org/apache/cassandra/io/sstable/IndexSummaryManager.java index b07b2f53f2..1dd3a4ea31 100644 --- a/src/java/org/apache/cassandra/io/sstable/IndexSummaryManager.java +++ b/src/java/org/apache/cassandra/io/sstable/IndexSummaryManager.java @@ -276,7 +276,7 @@ public class IndexSummaryManager implements IndexSummaryManagerMBean for (SSTableReader sstable : Iterables.concat(compacting, redistribute)) total += sstable.getIndexSummaryOffHeapSize(); - logger.debug("Beginning redistribution of index summaries for {} sstables with memory pool size {} MB; current spaced used is {} MB", + logger.trace("Beginning redistribution of index summaries for {} sstables with memory pool size {} MB; current spaced used is {} MB", redistribute.size(), memoryPoolBytes / 1024L / 1024L, total / 1024.0 / 1024.0); final Map readRates = new HashMap<>(redistribute.size()); @@ -310,7 +310,7 @@ public class IndexSummaryManager implements IndexSummaryManagerMBean total = 0; for (SSTableReader sstable : Iterables.concat(compacting, oldFormatSSTables, newSSTables)) total += sstable.getIndexSummaryOffHeapSize(); - logger.debug("Completed resizing of index summaries; current approximate memory used: {} MB", + logger.trace("Completed resizing of index summaries; current approximate memory used: {} MB", total / 1024.0 / 1024.0); return newSSTables; @@ -368,7 +368,7 @@ public class IndexSummaryManager implements IndexSummaryManagerMBean if (effectiveIndexInterval < minIndexInterval) { // The min_index_interval was changed; re-sample to match it. - logger.debug("Forcing resample of {} because the current index interval ({}) is below min_index_interval ({})", + logger.trace("Forcing resample of {} because the current index interval ({}) is below min_index_interval ({})", sstable, effectiveIndexInterval, minIndexInterval); long spaceUsed = (long) Math.ceil(avgEntrySize * numEntriesAtNewSamplingLevel); forceResample.add(new ResampleEntry(sstable, spaceUsed, newSamplingLevel)); @@ -377,7 +377,7 @@ public class IndexSummaryManager implements IndexSummaryManagerMBean else if (effectiveIndexInterval > maxIndexInterval) { // The max_index_interval was lowered; force an upsample to the effective minimum sampling level - logger.debug("Forcing upsample of {} because the current index interval ({}) is above max_index_interval ({})", + logger.trace("Forcing upsample of {} because the current index interval ({}) is above max_index_interval ({})", sstable, effectiveIndexInterval, maxIndexInterval); newSamplingLevel = Math.max(1, (BASE_SAMPLING_LEVEL * minIndexInterval) / maxIndexInterval); numEntriesAtNewSamplingLevel = IndexSummaryBuilder.entriesAtSamplingLevel(newSamplingLevel, sstable.getMaxIndexSummarySize()); @@ -424,7 +424,7 @@ public class IndexSummaryManager implements IndexSummaryManagerMBean for (ResampleEntry entry : toDownsample) { SSTableReader sstable = entry.sstable; - logger.debug("Re-sampling index summary for {} from {}/{} to {}/{} of the original number of entries", + logger.trace("Re-sampling index summary for {} from {}/{} to {}/{} of the original number of entries", sstable, sstable.getIndexSummarySamplingLevel(), Downsampling.BASE_SAMPLING_LEVEL, entry.newSamplingLevel, Downsampling.BASE_SAMPLING_LEVEL); ColumnFamilyStore cfs = Keyspace.open(sstable.metadata.ksName).getColumnFamilyStore(sstable.metadata.cfId); diff --git a/src/java/org/apache/cassandra/io/sstable/SSTable.java b/src/java/org/apache/cassandra/io/sstable/SSTable.java index 20771522de..b0aa89eef0 100644 --- a/src/java/org/apache/cassandra/io/sstable/SSTable.java +++ b/src/java/org/apache/cassandra/io/sstable/SSTable.java @@ -115,7 +115,7 @@ public abstract class SSTable } FileUtils.delete(desc.filenameFor(Component.SUMMARY)); - logger.debug("Deleted {}", desc); + logger.trace("Deleted {}", desc); return true; } diff --git a/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java b/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java index ce122060f7..87891ae2cb 100644 --- a/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java +++ b/src/java/org/apache/cassandra/io/sstable/format/SSTableReader.java @@ -296,7 +296,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted deserialize(Descriptor descriptor, EnumSet types) throws IOException { Map components; - logger.debug("Load metadata for {}", descriptor); + logger.trace("Load metadata for {}", descriptor); File statsFile = new File(descriptor.filenameFor(Component.STATS)); if (!statsFile.exists()) { - logger.debug("No sstable stats for {}", descriptor); + logger.trace("No sstable stats for {}", descriptor); components = Maps.newHashMap(); components.put(MetadataType.STATS, MetadataCollector.defaultStatsMetadata()); } @@ -129,7 +129,7 @@ public class MetadataSerializer implements IMetadataSerializer public void mutateLevel(Descriptor descriptor, int newLevel) throws IOException { - logger.debug("Mutating {} to level {}", descriptor.filenameFor(Component.STATS), newLevel); + logger.trace("Mutating {} to level {}", descriptor.filenameFor(Component.STATS), newLevel); Map currentComponents = deserialize(descriptor, EnumSet.allOf(MetadataType.class)); StatsMetadata stats = (StatsMetadata) currentComponents.remove(MetadataType.STATS); // mutate level @@ -139,7 +139,7 @@ public class MetadataSerializer implements IMetadataSerializer public void mutateRepairedAt(Descriptor descriptor, long newRepairedAt) throws IOException { - logger.debug("Mutating {} to repairedAt time {}", descriptor.filenameFor(Component.STATS), newRepairedAt); + logger.trace("Mutating {} to repairedAt time {}", descriptor.filenameFor(Component.STATS), newRepairedAt); Map currentComponents = deserialize(descriptor, EnumSet.allOf(MetadataType.class)); StatsMetadata stats = (StatsMetadata) currentComponents.remove(MetadataType.STATS); // mutate level diff --git a/src/java/org/apache/cassandra/io/util/FileUtils.java b/src/java/org/apache/cassandra/io/util/FileUtils.java index 9f5193b6c9..ce4537073e 100644 --- a/src/java/org/apache/cassandra/io/util/FileUtils.java +++ b/src/java/org/apache/cassandra/io/util/FileUtils.java @@ -170,8 +170,8 @@ public class FileUtils public static void renameWithConfirm(File from, File to) { assert from.exists(); - if (logger.isDebugEnabled()) - logger.debug((String.format("Renaming %s to %s", from.getPath(), to.getPath()))); + if (logger.isTraceEnabled()) + logger.trace((String.format("Renaming %s to %s", from.getPath(), to.getPath()))); // this is not FSWE because usually when we see it it's because we didn't close the file before renaming it, // and Windows is picky about that. try @@ -198,7 +198,7 @@ public class FileUtils } catch (AtomicMoveNotSupportedException e) { - logger.debug("Could not do an atomic move", e); + logger.trace("Could not do an atomic move", e); Files.move(from, to, StandardCopyOption.REPLACE_EXISTING); } @@ -393,7 +393,7 @@ public class FileUtils deleteRecursiveOnExit(new File(dir, child)); } - logger.debug("Scheduling deferred deletion of file: " + dir); + logger.trace("Scheduling deferred deletion of file: " + dir); dir.deleteOnExit(); } diff --git a/src/java/org/apache/cassandra/io/util/MmappedSegmentedFile.java b/src/java/org/apache/cassandra/io/util/MmappedSegmentedFile.java index 91908c969f..a8fae9fa6d 100644 --- a/src/java/org/apache/cassandra/io/util/MmappedSegmentedFile.java +++ b/src/java/org/apache/cassandra/io/util/MmappedSegmentedFile.java @@ -124,7 +124,7 @@ public class MmappedSegmentedFile extends SegmentedFile continue; FileUtils.clean(segment.right); } - logger.debug("All segments have been unmapped successfully"); + logger.trace("All segments have been unmapped successfully"); } catch (Exception e) { diff --git a/src/java/org/apache/cassandra/locator/AbstractReplicationStrategy.java b/src/java/org/apache/cassandra/locator/AbstractReplicationStrategy.java index 461265c17f..daa4aa01a5 100644 --- a/src/java/org/apache/cassandra/locator/AbstractReplicationStrategy.java +++ b/src/java/org/apache/cassandra/locator/AbstractReplicationStrategy.java @@ -84,7 +84,7 @@ public abstract class AbstractReplicationStrategy { if (lastVersion > lastInvalidatedVersion) { - logger.debug("clearing cached endpoints"); + logger.trace("clearing cached endpoints"); cachedEndpoints.clear(); lastInvalidatedVersion = lastVersion; } diff --git a/src/java/org/apache/cassandra/locator/NetworkTopologyStrategy.java b/src/java/org/apache/cassandra/locator/NetworkTopologyStrategy.java index 6959f294ad..307a07f072 100644 --- a/src/java/org/apache/cassandra/locator/NetworkTopologyStrategy.java +++ b/src/java/org/apache/cassandra/locator/NetworkTopologyStrategy.java @@ -71,7 +71,7 @@ public class NetworkTopologyStrategy extends AbstractReplicationStrategy } datacenters = Collections.unmodifiableMap(newDatacenters); - logger.debug("Configured datacenter replicas are {}", FBUtilities.toString(datacenters)); + logger.trace("Configured datacenter replicas are {}", FBUtilities.toString(datacenters)); } /** diff --git a/src/java/org/apache/cassandra/locator/PropertyFileSnitch.java b/src/java/org/apache/cassandra/locator/PropertyFileSnitch.java index 4bcdcc5c16..590117d649 100644 --- a/src/java/org/apache/cassandra/locator/PropertyFileSnitch.java +++ b/src/java/org/apache/cassandra/locator/PropertyFileSnitch.java @@ -99,7 +99,7 @@ public class PropertyFileSnitch extends AbstractNetworkTopologySnitch String[] value = endpointMap.get(endpoint); if (value == null) { - logger.debug("Could not find end point information for {}, will use default", endpoint); + logger.trace("Could not find end point information for {}, will use default", endpoint); return defaultDCRack; } return value; @@ -182,12 +182,12 @@ public class PropertyFileSnitch extends AbstractNetworkTopologySnitch throw new ConfigurationException(String.format("Snitch definitions at %s do not define a location for this node's broadcast address %s, nor does it provides a default", SNITCH_PROPERTIES_FILENAME, FBUtilities.getBroadcastAddress())); - if (logger.isDebugEnabled()) + if (logger.isTraceEnabled()) { StringBuilder sb = new StringBuilder(); for (Map.Entry entry : reloadedMap.entrySet()) sb.append(entry.getKey()).append(":").append(Arrays.toString(entry.getValue())).append(", "); - logger.debug("Loaded network topology from property file: {}", StringUtils.removeEnd(sb.toString(), ", ")); + logger.trace("Loaded network topology from property file: {}", StringUtils.removeEnd(sb.toString(), ", ")); } endpointMap = reloadedMap; diff --git a/src/java/org/apache/cassandra/locator/ReconnectableSnitchHelper.java b/src/java/org/apache/cassandra/locator/ReconnectableSnitchHelper.java index 3277af7e21..8b34fc0c9f 100644 --- a/src/java/org/apache/cassandra/locator/ReconnectableSnitchHelper.java +++ b/src/java/org/apache/cassandra/locator/ReconnectableSnitchHelper.java @@ -63,7 +63,7 @@ public class ReconnectableSnitchHelper implements IEndpointStateChangeSubscriber && !MessagingService.instance().getConnectionPool(publicAddress).endPoint().equals(localAddress)) { MessagingService.instance().getConnectionPool(publicAddress).reset(localAddress); - logger.debug(String.format("Intiated reconnect to an Internal IP %s for the %s", localAddress, publicAddress)); + logger.trace(String.format("Intiated reconnect to an Internal IP %s for the %s", localAddress, publicAddress)); } } diff --git a/src/java/org/apache/cassandra/locator/TokenMetadata.java b/src/java/org/apache/cassandra/locator/TokenMetadata.java index fc65dd8770..db0b609ffa 100644 --- a/src/java/org/apache/cassandra/locator/TokenMetadata.java +++ b/src/java/org/apache/cassandra/locator/TokenMetadata.java @@ -737,8 +737,8 @@ public class TokenMetadata if (bootstrapTokens.isEmpty() && leavingEndpoints.isEmpty() && movingEndpoints.isEmpty()) { - if (logger.isDebugEnabled()) - logger.debug("No bootstrapping, leaving or moving nodes -> empty pending ranges for {}", keyspaceName); + if (logger.isTraceEnabled()) + logger.trace("No bootstrapping, leaving or moving nodes -> empty pending ranges for {}", keyspaceName); pendingRanges.put(keyspaceName, newPendingRanges); return; @@ -802,8 +802,8 @@ public class TokenMetadata pendingRanges.put(keyspaceName, newPendingRanges); - if (logger.isDebugEnabled()) - logger.debug("Pending ranges:\n{}", (pendingRanges.isEmpty() ? "" : printPendingRanges())); + if (logger.isTraceEnabled()) + logger.trace("Pending ranges:\n{}", (pendingRanges.isEmpty() ? "" : printPendingRanges())); } finally { diff --git a/src/java/org/apache/cassandra/net/IncomingStreamingConnection.java b/src/java/org/apache/cassandra/net/IncomingStreamingConnection.java index 274e47bb9b..b69ce88af2 100644 --- a/src/java/org/apache/cassandra/net/IncomingStreamingConnection.java +++ b/src/java/org/apache/cassandra/net/IncomingStreamingConnection.java @@ -70,7 +70,7 @@ public class IncomingStreamingConnection extends Thread implements Closeable } catch (IOException e) { - logger.debug("IOException reading from socket; closing", e); + logger.trace("IOException reading from socket; closing", e); close(); } } @@ -87,7 +87,7 @@ public class IncomingStreamingConnection extends Thread implements Closeable } catch (IOException e) { - logger.debug("Error closing socket", e); + logger.trace("Error closing socket", e); } finally { diff --git a/src/java/org/apache/cassandra/net/IncomingTcpConnection.java b/src/java/org/apache/cassandra/net/IncomingTcpConnection.java index cfdb854000..f6652b0767 100644 --- a/src/java/org/apache/cassandra/net/IncomingTcpConnection.java +++ b/src/java/org/apache/cassandra/net/IncomingTcpConnection.java @@ -101,7 +101,7 @@ public class IncomingTcpConnection extends Thread implements Closeable } catch (IOException e) { - logger.debug("IOException reading from socket; closing", e); + logger.trace("IOException reading from socket; closing", e); } finally { @@ -121,7 +121,7 @@ public class IncomingTcpConnection extends Thread implements Closeable } catch (IOException e) { - logger.debug("Error closing socket", e); + logger.trace("Error closing socket", e); } finally { @@ -144,11 +144,11 @@ public class IncomingTcpConnection extends Thread implements Closeable from = CompactEndpointSerializationHelper.deserialize(in); // record the (true) version of the endpoint MessagingService.instance().setVersion(from, maxVersion); - logger.debug("Set version for {} to {} (will use {})", from, maxVersion, MessagingService.instance().getVersion(from)); + logger.trace("Set version for {} to {} (will use {})", from, maxVersion, MessagingService.instance().getVersion(from)); if (compressed) { - logger.debug("Upgrading incoming connection to be compressed"); + logger.trace("Upgrading incoming connection to be compressed"); if (version < MessagingService.VERSION_21) { in = new DataInputStream(new SnappyInputStream(socket.getInputStream())); @@ -206,7 +206,7 @@ public class IncomingTcpConnection extends Thread implements Closeable } else { - logger.debug("Received connection from newer protocol version {}. Ignoring message", version); + logger.trace("Received connection from newer protocol version {}. Ignoring message", version); } return message.from; } diff --git a/src/java/org/apache/cassandra/net/MessageDeliveryTask.java b/src/java/org/apache/cassandra/net/MessageDeliveryTask.java index 0ff0319c51..a46366c444 100644 --- a/src/java/org/apache/cassandra/net/MessageDeliveryTask.java +++ b/src/java/org/apache/cassandra/net/MessageDeliveryTask.java @@ -57,7 +57,7 @@ public class MessageDeliveryTask implements Runnable IVerbHandler verbHandler = MessagingService.instance().getVerbHandler(verb); if (verbHandler == null) { - logger.debug("Unknown verb {}", verb); + logger.trace("Unknown verb {}", verb); return; } diff --git a/src/java/org/apache/cassandra/net/MessagingService.java b/src/java/org/apache/cassandra/net/MessagingService.java index 1f3240d5d7..2a635533db 100644 --- a/src/java/org/apache/cassandra/net/MessagingService.java +++ b/src/java/org/apache/cassandra/net/MessagingService.java @@ -443,7 +443,7 @@ public final class MessagingService implements MessagingServiceMBean */ public void convict(InetAddress ep) { - logger.debug("Resetting pool for {}", ep); + logger.trace("Resetting pool for {}", ep); getConnectionPool(ep).reset(); } @@ -538,7 +538,7 @@ public final class MessagingService implements MessagingServiceMBean } catch (InterruptedException ie) { - logger.debug("await interrupted"); + logger.trace("await interrupted"); } } @@ -831,7 +831,7 @@ public final class MessagingService implements MessagingServiceMBean */ public int setVersion(InetAddress endpoint, int version) { - logger.debug("Setting version {} for {}", version, endpoint); + logger.trace("Setting version {} for {}", version, endpoint); if (version < VERSION_22) allNodesAtLeast22 = false; @@ -847,7 +847,7 @@ public final class MessagingService implements MessagingServiceMBean public void resetVersion(InetAddress endpoint) { - logger.debug("Resetting version for {}", endpoint); + logger.trace("Resetting version for {}", endpoint); Integer removed = versions.remove(endpoint); if (removed != null && removed <= VERSION_22) refreshAllNodesAtLeast22(); @@ -972,7 +972,7 @@ public final class MessagingService implements MessagingServiceMBean socket = server.accept(); if (!authenticate(socket)) { - logger.debug("remote failed to authenticate"); + logger.trace("remote failed to authenticate"); socket.close(); continue; } @@ -985,7 +985,7 @@ public final class MessagingService implements MessagingServiceMBean int header = in.readInt(); boolean isStream = MessagingService.getBits(header, 3, 1) == 1; int version = MessagingService.getBits(header, 15, 8); - logger.debug("Connection version {} from {}", version, socket.getInetAddress()); + logger.trace("Connection version {} from {}", version, socket.getInetAddress()); socket.setSoTimeout(0); Thread thread = isStream @@ -997,17 +997,17 @@ public final class MessagingService implements MessagingServiceMBean catch (AsynchronousCloseException e) { // this happens when another thread calls close(). - logger.debug("Asynchronous close seen by server thread"); + logger.trace("Asynchronous close seen by server thread"); break; } catch (ClosedChannelException e) { - logger.debug("MessagingService server thread already closed"); + logger.trace("MessagingService server thread already closed"); break; } catch (IOException e) { - logger.debug("Error reading the socket " + socket, e); + logger.trace("Error reading the socket " + socket, e); FileUtils.closeQuietly(socket); } } @@ -1016,7 +1016,7 @@ public final class MessagingService implements MessagingServiceMBean void close() throws IOException { - logger.debug("Closing accept() thread"); + logger.trace("Closing accept() thread"); try { diff --git a/src/java/org/apache/cassandra/net/OutboundTcpConnection.java b/src/java/org/apache/cassandra/net/OutboundTcpConnection.java index cb168bcbd5..31a5269bdd 100644 --- a/src/java/org/apache/cassandra/net/OutboundTcpConnection.java +++ b/src/java/org/apache/cassandra/net/OutboundTcpConnection.java @@ -295,8 +295,8 @@ public class OutboundTcpConnection extends Thread disconnect(); if (e instanceof IOException || e.getCause() instanceof IOException) { - if (logger.isDebugEnabled()) - logger.debug("error writing to {}", poolReference.endPoint(), e); + if (logger.isTraceEnabled()) + logger.trace("error writing to {}", poolReference.endPoint(), e); // if the message was important, such as a repair acknowledgement, put it back on the queue // to retry after re-connecting. See CASSANDRA-5393 @@ -371,8 +371,8 @@ public class OutboundTcpConnection extends Thread @SuppressWarnings("resource") private boolean connect() { - if (logger.isDebugEnabled()) - logger.debug("attempting to connect to {}", poolReference.endPoint()); + if (logger.isTraceEnabled()) + logger.trace("attempting to connect to {}", poolReference.endPoint()); long start = System.nanoTime(); long timeout = TimeUnit.MILLISECONDS.toNanos(DatabaseDescriptor.getRpcTimeout()); @@ -418,7 +418,7 @@ public class OutboundTcpConnection extends Thread // no version is returned, so disconnect an try again: we will either get // a different target version (targetVersion < MessagingService.VERSION_12) // or if the same version the handshake will finally succeed - logger.debug("Target max version is {}; no version information yet, will retry", maxTargetVersion); + logger.trace("Target max version is {}; no version information yet, will retry", maxTargetVersion); if (DatabaseDescriptor.getSeeds().contains(poolReference.endPoint())) logger.warn("Seed gossip version is {}; will not connect with that version", maxTargetVersion); disconnect(); @@ -431,7 +431,7 @@ public class OutboundTcpConnection extends Thread if (targetVersion > maxTargetVersion) { - logger.debug("Target max version is {}; will reconnect with that version", maxTargetVersion); + logger.trace("Target max version is {}; will reconnect with that version", maxTargetVersion); disconnect(); return false; } diff --git a/src/java/org/apache/cassandra/net/ResponseVerbHandler.java b/src/java/org/apache/cassandra/net/ResponseVerbHandler.java index 1d9aa98ef6..28ed365c8e 100644 --- a/src/java/org/apache/cassandra/net/ResponseVerbHandler.java +++ b/src/java/org/apache/cassandra/net/ResponseVerbHandler.java @@ -35,7 +35,7 @@ public class ResponseVerbHandler implements IVerbHandler if (callbackInfo == null) { String msg = "Callback already removed for {} (from {})"; - logger.debug(msg, id, message.from); + logger.trace(msg, id, message.from); Tracing.trace(msg, id, message.from); return; } diff --git a/src/java/org/apache/cassandra/schema/LegacySchemaTables.java b/src/java/org/apache/cassandra/schema/LegacySchemaTables.java index 30fe013938..5eae60ba70 100644 --- a/src/java/org/apache/cassandra/schema/LegacySchemaTables.java +++ b/src/java/org/apache/cassandra/schema/LegacySchemaTables.java @@ -1357,7 +1357,7 @@ public class LegacySchemaTables udf.body().equals(body) && udf.isCalledOnNullInput() == calledOnNullInput) { - logger.debug("Skipping duplicate compilation of already existing UDF {}", name); + logger.trace("Skipping duplicate compilation of already existing UDF {}", name); return udf; } } diff --git a/src/java/org/apache/cassandra/service/FileCacheService.java b/src/java/org/apache/cassandra/service/FileCacheService.java index 1e123101bf..19d6a70796 100644 --- a/src/java/org/apache/cassandra/service/FileCacheService.java +++ b/src/java/org/apache/cassandra/service/FileCacheService.java @@ -147,8 +147,8 @@ public class FileCacheService public void put(CacheKey cacheKey, RandomAccessReader instance) { int memoryUsed = memoryUsage.get(); - if (logger.isDebugEnabled()) - logger.debug("Estimated memory usage is {} compared to actual usage {}", memoryUsed, sizeInBytes()); + if (logger.isTraceEnabled()) + logger.trace("Estimated memory usage is {} compared to actual usage {}", memoryUsed, sizeInBytes()); CacheBucket bucket = cache.getIfPresent(cacheKey); if (memoryUsed >= MEMORY_USAGE_THRESHOLD || bucket == null) diff --git a/src/java/org/apache/cassandra/service/GCInspector.java b/src/java/org/apache/cassandra/service/GCInspector.java index 3a4ec229e9..89a4a7eddd 100644 --- a/src/java/org/apache/cassandra/service/GCInspector.java +++ b/src/java/org/apache/cassandra/service/GCInspector.java @@ -282,8 +282,8 @@ public class GCInspector implements NotificationListener, GCInspectorMXBean logger.warn(st); else if (duration > MIN_LOG_DURATION) logger.info(st); - else if (logger.isDebugEnabled()) - logger.debug(st); + else if (logger.isTraceEnabled()) + logger.trace(st); if (duration > STAT_THRESHOLD) StatusLogger.log(); diff --git a/src/java/org/apache/cassandra/service/LoadBroadcaster.java b/src/java/org/apache/cassandra/service/LoadBroadcaster.java index 238daae331..69fa93da22 100644 --- a/src/java/org/apache/cassandra/service/LoadBroadcaster.java +++ b/src/java/org/apache/cassandra/service/LoadBroadcaster.java @@ -87,8 +87,8 @@ public class LoadBroadcaster implements IEndpointStateChangeSubscriber { public void run() { - if (logger.isDebugEnabled()) - logger.debug("Disseminating load info ..."); + if (logger.isTraceEnabled()) + logger.trace("Disseminating load info ..."); Gossiper.instance.addLocalApplicationState(ApplicationState.LOAD, StorageService.instance.valueFactory.load(StorageMetrics.load.getCount())); } diff --git a/src/java/org/apache/cassandra/service/ReadCallback.java b/src/java/org/apache/cassandra/service/ReadCallback.java index 57d8064688..145679d4fc 100644 --- a/src/java/org/apache/cassandra/service/ReadCallback.java +++ b/src/java/org/apache/cassandra/service/ReadCallback.java @@ -109,8 +109,8 @@ public class ReadCallback implements IAsyncCallbackWithFail // 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()); + if (logger.isTraceEnabled()) + logger.trace("Read timeout: {}", ex.toString()); throw ex; } @@ -118,8 +118,8 @@ public class ReadCallback implements IAsyncCallbackWithFail { ReadFailureException ex = new ReadFailureException(consistencyLevel, received, failures, blockfor, resolver.isDataPresent()); - if (logger.isDebugEnabled()) - logger.debug("Read failure: {}", ex.toString()); + if (logger.isTraceEnabled()) + logger.trace("Read failure: {}", ex.toString()); throw ex; } @@ -210,8 +210,8 @@ public class ReadCallback implements IAsyncCallbackWithFail if (traceState != null) traceState.trace("Digest mismatch: {}", e.toString()); - if (logger.isDebugEnabled()) - logger.debug("Digest mismatch:", e); + if (logger.isTraceEnabled()) + logger.trace("Digest mismatch:", e); ReadRepairMetrics.repairedBackground.mark(); diff --git a/src/java/org/apache/cassandra/service/RowDataResolver.java b/src/java/org/apache/cassandra/service/RowDataResolver.java index e935ce7aed..e15302b255 100644 --- a/src/java/org/apache/cassandra/service/RowDataResolver.java +++ b/src/java/org/apache/cassandra/service/RowDataResolver.java @@ -59,8 +59,8 @@ public class RowDataResolver extends AbstractRowResolver public Row resolve() throws DigestMismatchException { int replyCount = replies.size(); - if (logger.isDebugEnabled()) - logger.debug("resolving {} responses", replyCount); + if (logger.isTraceEnabled()) + logger.trace("resolving {} responses", replyCount); long start = System.nanoTime(); ColumnFamily resolved; @@ -84,8 +84,8 @@ public class RowDataResolver extends AbstractRowResolver } resolved = resolveSuperset(versions, timestamp); - if (logger.isDebugEnabled()) - logger.debug("versions merged"); + if (logger.isTraceEnabled()) + logger.trace("versions merged"); // send updates to any replica that was missing part of the full row // (resolved can be null even if versions doesn't have all nulls because of the call to removeDeleted in resolveSuperSet) @@ -97,8 +97,8 @@ public class RowDataResolver extends AbstractRowResolver resolved = replies.get(0).payload.row().cf; } - if (logger.isDebugEnabled()) - logger.debug("resolve: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + if (logger.isTraceEnabled()) + logger.trace("resolve: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); return new Row(key, resolved); } diff --git a/src/java/org/apache/cassandra/service/RowDigestResolver.java b/src/java/org/apache/cassandra/service/RowDigestResolver.java index 95b5b808a5..32b26e1f08 100644 --- a/src/java/org/apache/cassandra/service/RowDigestResolver.java +++ b/src/java/org/apache/cassandra/service/RowDigestResolver.java @@ -63,8 +63,8 @@ public class RowDigestResolver extends AbstractRowResolver */ public Row resolve() throws DigestMismatchException { - if (logger.isDebugEnabled()) - logger.debug("resolving {} responses", replies.size()); + if (logger.isTraceEnabled()) + logger.trace("resolving {} responses", replies.size()); long start = System.nanoTime(); @@ -98,8 +98,8 @@ public class RowDigestResolver extends AbstractRowResolver throw new DigestMismatchException(key, digest, newDigest); } - if (logger.isDebugEnabled()) - logger.debug("resolve: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); + if (logger.isTraceEnabled()) + logger.trace("resolve: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start)); return new Row(key, data); } diff --git a/src/java/org/apache/cassandra/service/StorageProxy.java b/src/java/org/apache/cassandra/service/StorageProxy.java index e57208ac6e..af56c3a48d 100644 --- a/src/java/org/apache/cassandra/service/StorageProxy.java +++ b/src/java/org/apache/cassandra/service/StorageProxy.java @@ -984,7 +984,7 @@ public class StorageProxy implements StorageProxyMBean int ttl = HintedHandOffManager.calculateHintTTL(mutation); if (ttl > 0) { - logger.debug("Adding hint for {}", target); + logger.trace("Adding hint for {}", target); writeHintForMutation(mutation, System.currentTimeMillis(), ttl, target); // Notify the handler only for CL == ANY if (responseHandler != null && responseHandler.consistencyLevel == ConsistencyLevel.ANY) @@ -1390,8 +1390,8 @@ public class StorageProxy implements StorageProxyMBean rows.add(row); } - if (logger.isDebugEnabled()) - logger.debug("Read: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - exec.handler.start)); + if (logger.isTraceEnabled()) + logger.trace("Read: {} ms.", TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - exec.handler.start)); } catch (ReadTimeoutException|ReadFailureException ex) { @@ -1469,7 +1469,7 @@ public class StorageProxy implements StorageProxyMBean if (Tracing.isTracing()) Tracing.trace("Timed out waiting on digest mismatch repair requests"); else - logger.debug("Timed out waiting on digest mismatch repair requests"); + logger.trace("Timed out waiting on digest mismatch repair requests"); // the caught exception here will have CL.ALL from the repair command, // not whatever CL the initial command was at (CASSANDRA-7947) int blockFor = consistencyLevel.blockFor(Keyspace.open(command.getKeyspace())); @@ -1488,7 +1488,7 @@ public class StorageProxy implements StorageProxyMBean if (Tracing.isTracing()) Tracing.trace("Timed out waiting on digest mismatch repair acknowledgements"); else - logger.debug("Timed out waiting on digest mismatch repair acknowledgements"); + logger.trace("Timed out waiting on digest mismatch repair acknowledgements"); int blockFor = consistencyLevel.blockFor(Keyspace.open(command.getKeyspace())); throw new ReadTimeoutException(consistencyLevel, blockFor-1, blockFor, true); } @@ -1710,7 +1710,7 @@ public class StorageProxy implements StorageProxyMBean ? 1 : Math.max(1, Math.min(ranges.size(), (int) Math.ceil(command.limit() / resultRowsPerRange))); - logger.debug("Estimated result rows per range: {}; requested rows: {}, ranges.size(): {}; concurrent range requests: {}", + logger.trace("Estimated result rows per range: {}; requested rows: {}, ranges.size(): {}; concurrent range requests: {}", resultRowsPerRange, command.limit(), ranges.size(), @@ -1896,7 +1896,7 @@ public class StorageProxy implements StorageProxyMBean actualRowsPerRange = fetchedRows / i; concurrencyFactor = Math.max(1, Math.min(ranges.size() - i, Math.round(remainingRows / actualRowsPerRange))); } - logger.debug("Didn't get enough response rows; actual rows per range: {}; remaining rows: {}, new concurrent requests: {}", + logger.trace("Didn't get enough response rows; actual rows per range: {}; remaining rows: {}, new concurrent requests: {}", actualRowsPerRange, (int) remainingRows, concurrencyFactor); } } diff --git a/src/java/org/apache/cassandra/thrift/CassandraServer.java b/src/java/org/apache/cassandra/thrift/CassandraServer.java index 64662bfae9..1abc928973 100644 --- a/src/java/org/apache/cassandra/thrift/CassandraServer.java +++ b/src/java/org/apache/cassandra/thrift/CassandraServer.java @@ -295,7 +295,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("get_slice"); + logger.trace("get_slice"); } try @@ -343,7 +343,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("multiget_slice"); + logger.trace("multiget_slice"); } try @@ -450,7 +450,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("get"); + logger.trace("get"); } try @@ -519,7 +519,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("get_count"); + logger.trace("get_count"); } try @@ -541,7 +541,7 @@ public class CassandraServer implements Cassandra.Iface int averageColumnSize = (int) (cfs.metric.meanRowSize.getValue() / cfs.getMeanColumns()); pageSize = Math.min(COUNT_PAGE_SIZE, 4 * 1024 * 1024 / averageColumnSize); pageSize = Math.max(2, pageSize); - logger.debug("average row column size is {}; using pageSize of {}", averageColumnSize, pageSize); + logger.trace("average row column size is {}; using pageSize of {}", averageColumnSize, pageSize); } else { @@ -599,7 +599,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("multiget_count"); + logger.trace("multiget_count"); } try @@ -680,7 +680,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("insert"); + logger.trace("insert"); } try @@ -720,7 +720,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("cas"); + logger.trace("cas"); } try @@ -947,7 +947,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("batch_mutate"); + logger.trace("batch_mutate"); } try @@ -980,7 +980,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("atomic_batch_mutate"); + logger.trace("atomic_batch_mutate"); } try @@ -1039,7 +1039,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("remove"); + logger.trace("remove"); } try @@ -1126,7 +1126,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("range_slice"); + logger.trace("range_slice"); } try @@ -1210,7 +1210,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("get_paged_slice"); + logger.trace("get_paged_slice"); } try @@ -1305,7 +1305,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("scan"); + logger.trace("scan"); } try @@ -1495,7 +1495,7 @@ public class CassandraServer implements Cassandra.Iface public String system_add_column_family(CfDef cf_def) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("add_column_family"); + logger.trace("add_column_family"); try { @@ -1522,7 +1522,7 @@ public class CassandraServer implements Cassandra.Iface public String system_drop_column_family(String column_family) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("drop_column_family"); + logger.trace("drop_column_family"); ThriftClientState cState = state(); @@ -1542,7 +1542,7 @@ public class CassandraServer implements Cassandra.Iface public String system_add_keyspace(KsDef ks_def) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("add_keyspace"); + logger.trace("add_keyspace"); try { @@ -1583,7 +1583,7 @@ public class CassandraServer implements Cassandra.Iface public String system_drop_keyspace(String keyspace) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("drop_keyspace"); + logger.trace("drop_keyspace"); try { @@ -1605,7 +1605,7 @@ public class CassandraServer implements Cassandra.Iface public String system_update_keyspace(KsDef ks_def) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("update_keyspace"); + logger.trace("update_keyspace"); try { @@ -1627,7 +1627,7 @@ public class CassandraServer implements Cassandra.Iface public String system_update_column_family(CfDef cf_def) throws InvalidRequestException, SchemaDisagreementException, TException { - logger.debug("update_column_family"); + logger.trace("update_column_family"); try { @@ -1674,7 +1674,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("truncating {}.{}", cState.getKeyspace(), cfname); + logger.trace("truncating {}.{}", cState.getKeyspace(), cfname); } schedule(DatabaseDescriptor.getTruncateRpcTimeout()); @@ -1723,7 +1723,7 @@ public class CassandraServer implements Cassandra.Iface public Map> describe_schema_versions() throws TException, InvalidRequestException { - logger.debug("checking schema agreement"); + logger.trace("checking schema agreement"); return StorageProxy.describeSchemaVersions(); } @@ -1741,7 +1741,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("add"); + logger.trace("add"); } try @@ -1797,7 +1797,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("remove_counter"); + logger.trace("remove_counter"); } try @@ -1890,7 +1890,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("execute_cql3_query"); + logger.trace("execute_cql3_query"); } ThriftClientState cState = state(); @@ -1920,7 +1920,7 @@ public class CassandraServer implements Cassandra.Iface public CqlPreparedResult prepare_cql3_query(ByteBuffer query, Compression compression) throws TException { - logger.debug("prepare_cql3_query"); + logger.trace("prepare_cql3_query"); String queryString = uncompress(query, compression); ThriftClientState cState = state(); @@ -1952,7 +1952,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("execute_prepared_cql3_query"); + logger.trace("execute_prepared_cql3_query"); } try @@ -2001,7 +2001,7 @@ public class CassandraServer implements Cassandra.Iface } else { - logger.debug("get_multi_slice"); + logger.trace("get_multi_slice"); } try { diff --git a/src/java/org/apache/cassandra/thrift/CustomTThreadPoolServer.java b/src/java/org/apache/cassandra/thrift/CustomTThreadPoolServer.java index a025004172..bde5310535 100644 --- a/src/java/org/apache/cassandra/thrift/CustomTThreadPoolServer.java +++ b/src/java/org/apache/cassandra/thrift/CustomTThreadPoolServer.java @@ -126,7 +126,7 @@ public class CustomTThreadPoolServer extends TServer catch (RejectedExecutionException e) { // worker thread decremented activeClients but hadn't finished exiting - logger.debug("Dropping client connection because our limit of {} has been reached", args.maxWorkerThreads); + logger.trace("Dropping client connection because our limit of {} has been reached", args.maxWorkerThreads); continue; } @@ -211,7 +211,7 @@ public class CustomTThreadPoolServer extends TServer { // Assume the client died and continue silently // Log at debug to allow debugging of "frame too large" errors (see CASSANDRA-3142). - logger.debug("Thrift transport error occurred during processing of message.", ttx); + logger.trace("Thrift transport error occurred during processing of message.", ttx); } catch (TException tx) { diff --git a/src/java/org/apache/cassandra/thrift/ThriftValidation.java b/src/java/org/apache/cassandra/thrift/ThriftValidation.java index 376895229e..d735676533 100644 --- a/src/java/org/apache/cassandra/thrift/ThriftValidation.java +++ b/src/java/org/apache/cassandra/thrift/ThriftValidation.java @@ -451,8 +451,8 @@ public class ThriftValidation } catch (MarshalException me) { - if (logger.isDebugEnabled()) - logger.debug("rejecting invalid value {}", ByteBufferUtil.bytesToHex(summarize(column.value))); + if (logger.isTraceEnabled()) + logger.trace("rejecting invalid value {}", ByteBufferUtil.bytesToHex(summarize(column.value))); throw new org.apache.cassandra.exceptions.InvalidRequestException(String.format("(%s) [%s][%s][%s] failed validation", me.getMessage(), diff --git a/src/java/org/apache/cassandra/tracing/Tracing.java b/src/java/org/apache/cassandra/tracing/Tracing.java index 3f9f54db10..ccc2637141 100644 --- a/src/java/org/apache/cassandra/tracing/Tracing.java +++ b/src/java/org/apache/cassandra/tracing/Tracing.java @@ -152,7 +152,7 @@ public class Tracing TraceState state = this.state.get(); if (state == null) // inline isTracing to avoid implicit two calls to state.get() { - logger.debug("request complete"); + logger.trace("request complete"); } else { diff --git a/src/java/org/apache/cassandra/transport/Message.java b/src/java/org/apache/cassandra/transport/Message.java index 440d48165f..ab794dfb57 100644 --- a/src/java/org/apache/cassandra/transport/Message.java +++ b/src/java/org/apache/cassandra/transport/Message.java @@ -503,7 +503,7 @@ public abstract class Message QueryState qstate = connection.validateNewMessage(request.type, connection.getVersion(), request.getStreamId()); - logger.debug("Received: {}, v={}", request, connection.getVersion()); + logger.trace("Received: {}, v={}", request, connection.getVersion()); response = request.execute(qstate); response.setStreamId(request.getStreamId()); response.setWarnings(ClientWarn.getWarnings()); @@ -522,7 +522,7 @@ public abstract class Message ClientWarn.resetWarnings(); } - logger.debug("Responding: {}, v={}", response, connection.getVersion()); + logger.trace("Responding: {}, v={}", response, connection.getVersion()); flush(new FlushItem(ctx, response, request.getSourceFrame())); } @@ -597,7 +597,7 @@ public abstract class Message if (ioExceptionsAtDebugLevel.contains(exception.getMessage())) { // Likely unclean client disconnects - logger.debug(message, exception); + logger.trace(message, exception); } else { diff --git a/src/java/org/apache/cassandra/triggers/CustomClassLoader.java b/src/java/org/apache/cassandra/triggers/CustomClassLoader.java index ecb34a25cd..965da4b9e8 100644 --- a/src/java/org/apache/cassandra/triggers/CustomClassLoader.java +++ b/src/java/org/apache/cassandra/triggers/CustomClassLoader.java @@ -112,7 +112,7 @@ public class CustomClassLoader extends URLClassLoader } catch (ClassNotFoundException ex) { - logger.debug("Class not found using parent class loader,", ex); + logger.trace("Class not found using parent class loader,", ex); // Don't throw the exception here, try triggers directory. } Class clazz = this.findClass(name); diff --git a/src/java/org/apache/cassandra/utils/CLibrary.java b/src/java/org/apache/cassandra/utils/CLibrary.java index fed314bd8c..4ca5d53b71 100644 --- a/src/java/org/apache/cassandra/utils/CLibrary.java +++ b/src/java/org/apache/cassandra/utils/CLibrary.java @@ -70,7 +70,7 @@ public final class CLibrary catch (UnsatisfiedLinkError e) { logger.warn("JNA link failure, one or more native method will be unavailable."); - logger.debug("JNA link failure details: {}", e.getMessage()); + logger.trace("JNA link failure details: {}", e.getMessage()); } catch (NoSuchMethodError e) { diff --git a/src/java/org/apache/cassandra/utils/EstimatedHistogram.java b/src/java/org/apache/cassandra/utils/EstimatedHistogram.java index a5c51c8155..93d142ab53 100644 --- a/src/java/org/apache/cassandra/utils/EstimatedHistogram.java +++ b/src/java/org/apache/cassandra/utils/EstimatedHistogram.java @@ -234,7 +234,7 @@ public class EstimatedHistogram } /** - * log.debug() every record in the histogram + * log.trace() every record in the histogram * * @param log */ @@ -265,7 +265,7 @@ public class EstimatedHistogram // calculation, and accept the unnecessary whitespace prefixes that will occasionally occur if (i == 0 && count == 0) continue; - log.debug(String.format(formatstr, names[i], count)); + log.trace(String.format(formatstr, names[i], count)); } } diff --git a/src/java/org/apache/cassandra/utils/Mx4jTool.java b/src/java/org/apache/cassandra/utils/Mx4jTool.java index e8fdb29b95..41a5b332b3 100644 --- a/src/java/org/apache/cassandra/utils/Mx4jTool.java +++ b/src/java/org/apache/cassandra/utils/Mx4jTool.java @@ -42,7 +42,7 @@ public class Mx4jTool { try { - logger.debug("Will try to load mx4j now, if it's in the classpath"); + logger.trace("Will try to load mx4j now, if it's in the classpath"); MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); ObjectName processorName = new ObjectName("Server:name=XSLTProcessor"); @@ -65,7 +65,7 @@ public class Mx4jTool } catch (ClassNotFoundException e) { - logger.debug("Will not load MX4J, mx4j-tools.jar is not in the classpath"); + logger.trace("Will not load MX4J, mx4j-tools.jar is not in the classpath"); } catch(Exception e) { diff --git a/src/java/org/apache/cassandra/utils/OutputHandler.java b/src/java/org/apache/cassandra/utils/OutputHandler.java index b2036639fb..88c54cedd3 100644 --- a/src/java/org/apache/cassandra/utils/OutputHandler.java +++ b/src/java/org/apache/cassandra/utils/OutputHandler.java @@ -44,7 +44,7 @@ public interface OutputHandler public void debug(String msg) { - logger.debug(msg); + logger.trace(msg); } public void warn(String msg) diff --git a/src/java/org/apache/cassandra/utils/TopKSampler.java b/src/java/org/apache/cassandra/utils/TopKSampler.java index a8bd602d81..37fcb60038 100644 --- a/src/java/org/apache/cassandra/utils/TopKSampler.java +++ b/src/java/org/apache/cassandra/utils/TopKSampler.java @@ -110,7 +110,7 @@ public class TopKSampler hll.offerHashed(hash); } catch (Exception e) { - logger.debug("Failure to offer sample", e); + logger.trace("Failure to offer sample", e); } } }