mirror of https://github.com/apache/cassandra
Add a separate production debug log for troubleshooting
patch by Paulo Motta; reviewed by Ariel Weisberg for CASSANDRA-10241
This commit is contained in:
Paulo Motta
blerer
parent
f3ad68cb4e
commit
4a849efeb7
10
NEWS.txt
10
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
|
||||
|
|
|
|||
|
|
@ -17,28 +17,67 @@
|
|||
under the License.
|
||||
-->
|
||||
|
||||
<!--
|
||||
In order to disable debug.log, comment-out the ASYNCDEBUGLOG
|
||||
appender reference in the root level section below.
|
||||
-->
|
||||
|
||||
<configuration scan="true">
|
||||
<jmxConfigurator />
|
||||
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
|
||||
<shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook"/>
|
||||
|
||||
<!-- SYSTEMLOG rolling file appender to system.log (INFO level) -->
|
||||
|
||||
<appender name="SYSTEMLOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
|
||||
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
|
||||
<level>INFO</level>
|
||||
</filter>
|
||||
<file>${cassandra.logdir}/system.log</file>
|
||||
<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
|
||||
<fileNamePattern>${cassandra.logdir}/system.log.%i.zip</fileNamePattern>
|
||||
<minIndex>1</minIndex>
|
||||
<maxIndex>20</maxIndex>
|
||||
</rollingPolicy>
|
||||
|
||||
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
|
||||
<maxFileSize>20MB</maxFileSize>
|
||||
</triggeringPolicy>
|
||||
<encoder>
|
||||
<pattern>%-5level [%thread] %date{ISO8601} %F:%L - %msg%n</pattern>
|
||||
<!-- old-style log format
|
||||
<pattern>%5level [%thread] %date{ISO8601} %F (line %L) %msg%n</pattern>
|
||||
-->
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
|
||||
<!-- DEBUGLOG rolling file appender to debug.log (all levels) -->
|
||||
|
||||
<appender name="DEBUGLOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
|
||||
<file>${cassandra.logdir}/debug.log</file>
|
||||
<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
|
||||
<fileNamePattern>${cassandra.logdir}/debug.log.%i.zip</fileNamePattern>
|
||||
<minIndex>1</minIndex>
|
||||
<maxIndex>20</maxIndex>
|
||||
</rollingPolicy>
|
||||
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
|
||||
<maxFileSize>20MB</maxFileSize>
|
||||
</triggeringPolicy>
|
||||
<encoder>
|
||||
<pattern>%-5level [%thread] %date{ISO8601} %F:%L - %msg%n</pattern>
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
<!-- ASYNCLOG assynchronous appender to debug.log (all levels) -->
|
||||
|
||||
<appender name="ASYNCDEBUGLOG" class="ch.qos.logback.classic.AsyncAppender">
|
||||
<queueSize>1024</queueSize>
|
||||
<discardingThreshold>0</discardingThreshold>
|
||||
<includeCallerData>true</includeCallerData>
|
||||
<appender-ref ref="DEBUGLOG" />
|
||||
</appender>
|
||||
|
||||
<!-- STDOUT console appender to stdout (INFO level) -->
|
||||
|
||||
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
|
||||
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
|
||||
<level>INFO</level>
|
||||
</filter>
|
||||
<encoder>
|
||||
<pattern>%-5level %date{HH:mm:ss,SSS} %msg%n</pattern>
|
||||
</encoder>
|
||||
|
|
@ -49,12 +88,14 @@
|
|||
-->
|
||||
|
||||
<root level="INFO">
|
||||
<appender-ref ref="FILE" />
|
||||
<appender-ref ref="SYSTEMLOG" />
|
||||
<appender-ref ref="STDOUT" />
|
||||
<appender-ref ref="ASYNCDEBUGLOG" /> <!-- Comment this line to disable debug.log -->
|
||||
<!--
|
||||
<appender-ref ref="LogbackMetrics" />
|
||||
-->
|
||||
</root>
|
||||
|
||||
|
||||
<logger name="org.apache.cassandra" level="DEBUG"/>
|
||||
<logger name="com.thinkaurelius.thrift" level="ERROR"/>
|
||||
</configuration>
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -256,8 +256,8 @@ public class AutoSavingCache<K extends CacheKey, V> extends InstrumentingCache<K
|
|||
FileUtils.closeQuietly(in);
|
||||
}
|
||||
}
|
||||
if (logger.isDebugEnabled())
|
||||
logger.debug("completed reading ({} ms; {} keys) saved cache {}",
|
||||
if (logger.isTraceEnabled())
|
||||
logger.trace("completed reading ({} ms; {} keys) saved cache {}",
|
||||
TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start), count, dataPath);
|
||||
return count;
|
||||
}
|
||||
|
|
@ -320,12 +320,12 @@ public class AutoSavingCache<K extends CacheKey, V> extends InstrumentingCache<K
|
|||
|
||||
public void saveCache()
|
||||
{
|
||||
logger.debug("Deleting old {} files.", cacheType);
|
||||
logger.trace("Deleting old {} files.", cacheType);
|
||||
deleteOldCacheFiles();
|
||||
|
||||
if (!keyIterator.hasNext())
|
||||
{
|
||||
logger.debug("Skipping {} save, cache is empty.", cacheType);
|
||||
logger.trace("Skipping {} save, cache is empty.", cacheType);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public class SerializingCache<K, V> implements ICache<K, V>
|
|||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<Mutation> 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;
|
||||
|
|
|
|||
|
|
@ -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<Descriptor,Set<Component>> sstableFiles : directories.sstableLister().list().entrySet())
|
||||
{
|
||||
|
|
@ -649,7 +649,7 @@ public class ColumnFamilyStore implements ColumnFamilyStoreMBean
|
|||
{
|
||||
HashSet<Integer> 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<SSTableReader> getOverlappingSSTables(Iterable<SSTableReader> 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> V runWithCompactionsDisabled(Callable<V> 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<ColumnFamilyStore> 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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ public class CounterMutationVerbHandler implements IVerbHandler<CounterMutation>
|
|||
public void doVerb(final MessageIn<CounterMutation> 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,
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ public class DefinitionsUpdateVerbHandler implements IVerbHandler<Collection<Mut
|
|||
|
||||
public void doVerb(final MessageIn<Collection<Mutation>> 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()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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<String> 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())
|
||||
{
|
||||
|
|
|
|||
|
|
@ -360,13 +360,13 @@ public class Memtable implements Comparable<Memtable>
|
|||
|
||||
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<Memtable>
|
|||
|
||||
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<Memtable>
|
|||
}
|
||||
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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<Collection<Mutation>> response = new MessageOut<>(MessagingService.Verb.INTERNAL_RESPONSE,
|
||||
LegacySchemaTables.convertSchemaToMutations(),
|
||||
MigrationManager.MigrationsSerializer.instance);
|
||||
|
|
|
|||
|
|
@ -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<UUID> response = new MessageOut<UUID>(MessagingService.Verb.INTERNAL_RESPONSE, Schema.instance.getVersion(), UUIDSerializer.serializer);
|
||||
MessagingService.instance().sendReply(response, id, message.from);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<Token> 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);
|
||||
|
|
|
|||
|
|
@ -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<SliceQueryFilter, SliceQueryFilter> newFilters = filter.splitOutStaticSlice(cfm);
|
||||
|
||||
Row normalResults = keyspace.getRow(new QueryFilter(dk, cfName, newFilters.right, timestamp));
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ public class CompactionController implements AutoCloseable
|
|||
*/
|
||||
public static Set<SSTableReader> getFullyExpiredSSTables(ColumnFamilyStore cfStore, Iterable<SSTableReader> compacting, Iterable<SSTableReader> overlapping, int gcBefore)
|
||||
{
|
||||
logger.debug("Checking droppable sstables in {}", cfStore);
|
||||
logger.trace("Checking droppable sstables in {}", cfStore);
|
||||
|
||||
if (compacting == null)
|
||||
return Collections.<SSTableReader>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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<SSTableReader> sstables = new HashSet<>(validatedForRepair);
|
||||
Set<SSTableReader> mutatedRepairStatuses = new HashSet<>();
|
||||
Set<SSTableReader> 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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -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<SSTableReader> 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<SSTableReader> candidates = filterOldSSTables(Lists.newArrayList(candidateSSTables), options.maxSSTableAge, now);
|
||||
|
||||
List<List<SSTableReader>> buckets = getBuckets(createSSTableAndMinTimestampPairs(candidates), options.baseTime, base, now);
|
||||
logger.debug("Compaction buckets are {}", buckets);
|
||||
logger.trace("Compaction buckets are {}", buckets);
|
||||
updateEstimatedCompactionsByTasks(buckets);
|
||||
List<SSTableReader> 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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
|
|
@ -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<SSTableReader> sstablesInLevel = Sets.newHashSet(sstables);
|
||||
Set<SSTableReader> 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<SSTableReader> 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<SSTableReader> getCandidatesFor(int level)
|
||||
{
|
||||
assert !getLevel(level).isEmpty();
|
||||
logger.debug("Choosing candidates for L{}", level);
|
||||
logger.trace("Choosing candidates for L{}", level);
|
||||
|
||||
final Set<SSTableReader> 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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ public class SizeTieredCompactionStrategy extends AbstractCompactionStrategy
|
|||
Iterable<SSTableReader> candidates = filterSuspectSSTables(Sets.intersection(cfs.getUncompactingSSTables(), sstables));
|
||||
|
||||
List<List<SSTableReader>> 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<SSTableReader> 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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ public class DefaultCompactionWriter extends CompactionAwareWriter
|
|||
public DefaultCompactionWriter(ColumnFamilyStore cfs, LifecycleTransaction txn, Set<SSTableReader> 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")
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -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<SSTableReader> 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<SSTableReader> 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;
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ public class BootStrapper extends ProgressEventNotifierSupport
|
|||
|
||||
public ListenableFuture<StreamState> 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<Token> tokens = new ArrayList<>(initialTokens.size());
|
||||
for (String tokenString : initialTokens)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -146,18 +146,18 @@ public class RangeStreamer
|
|||
Multimap<Range<Token>, InetAddress> rangesForKeyspace = useStrictSourcesForRanges(keyspaceName)
|
||||
? getAllRangesWithStrictSourcesFor(keyspaceName, ranges) : getAllRangesWithSourcesFor(keyspaceName, ranges);
|
||||
|
||||
if (logger.isDebugEnabled())
|
||||
if (logger.isTraceEnabled())
|
||||
{
|
||||
for (Map.Entry<Range<Token>, 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<InetAddress, Collection<Range<Token>>> entry : getRangeFetchMap(rangesForKeyspace, sourceFilters, keyspaceName).asMap().entrySet())
|
||||
{
|
||||
if (logger.isDebugEnabled())
|
||||
if (logger.isTraceEnabled())
|
||||
{
|
||||
for (Range<Token> 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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ public abstract class AbstractColumnFamilyInputFormat<K, Y> 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<TokenRange, Set<Host>> masterRangeNodes = getRangeMap(conf, keyspace);
|
||||
|
|
@ -219,7 +219,7 @@ public abstract class AbstractColumnFamilyInputFormat<K, Y> extends InputFormat<
|
|||
subSplits.get(subSplit),
|
||||
endpoints);
|
||||
|
||||
logger.debug("adding {}", split);
|
||||
logger.trace("adding {}", split);
|
||||
splits.add(split);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ public class ColumnFamilyInputFormat extends AbstractColumnFamilyInputFormat<Byt
|
|||
@SuppressWarnings("resource")
|
||||
public static Cassandra.Client createAuthenticatedClient(String location, int port, Configuration conf) throws Exception
|
||||
{
|
||||
logger.debug("Creating authenticated client for CF input format");
|
||||
logger.trace("Creating authenticated client for CF input format");
|
||||
TTransport transport;
|
||||
try
|
||||
{
|
||||
|
|
@ -86,7 +86,7 @@ public class ColumnFamilyInputFormat extends AbstractColumnFamilyInputFormat<Byt
|
|||
AuthenticationRequest authRequest = new AuthenticationRequest(creds);
|
||||
client.login(authRequest);
|
||||
}
|
||||
logger.debug("Authenticated client for CF input format created successfully");
|
||||
logger.trace("Authenticated client for CF input format created successfully");
|
||||
return client;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ public class ColumnFamilyOutputFormat extends OutputFormat<ByteBuffer,List<Mutat
|
|||
@SuppressWarnings("resource")
|
||||
public static Cassandra.Client createAuthenticatedClient(String host, int port, Configuration conf) throws Exception
|
||||
{
|
||||
logger.debug("Creating authenticated client for CF output format");
|
||||
logger.trace("Creating authenticated client for CF output format");
|
||||
TTransport transport = ConfigHelper.getClientTransportFactory(conf).openTransport(host, port);
|
||||
TProtocol binaryProtocol = new TBinaryProtocol(transport, true, true);
|
||||
Cassandra.Client client = new Cassandra.Client(binaryProtocol);
|
||||
|
|
@ -127,7 +127,7 @@ public class ColumnFamilyOutputFormat extends OutputFormat<ByteBuffer,List<Mutat
|
|||
if ((user != null) && (password != null))
|
||||
login(user, password, client);
|
||||
|
||||
logger.debug("Authenticated client for CF output format created successfully");
|
||||
logger.trace("Authenticated client for CF output format created successfully");
|
||||
return client;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -170,14 +170,14 @@ public class ColumnFamilyRecordReader extends RecordReader<ByteBuffer, SortedMap
|
|||
}
|
||||
|
||||
iter = widerows ? new WideRowIterator() : new StaticRowIterator();
|
||||
logger.debug("created {}", iter);
|
||||
logger.trace("created {}", iter);
|
||||
}
|
||||
|
||||
public boolean nextKeyValue() throws IOException
|
||||
{
|
||||
if (!iter.hasNext())
|
||||
{
|
||||
logger.debug("Finished scanning {} rows (estimate was: {})", iter.rowsRead(), totalRowCount);
|
||||
logger.trace("Finished scanning {} rows (estimate was: {})", iter.rowsRead(), totalRowCount);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -443,7 +443,7 @@ public class ColumnFamilyRecordReader extends RecordReader<ByteBuffer, SortedMap
|
|||
else
|
||||
{
|
||||
KeySlice lastRow = Iterables.getLast(rows);
|
||||
logger.debug("Starting with last-seen row {}", lastRow.key);
|
||||
logger.trace("Starting with last-seen row {}", lastRow.key);
|
||||
keyRange = new KeyRange(batchSize)
|
||||
.setStart_key(lastRow.key)
|
||||
.setEnd_token(split.getEndToken())
|
||||
|
|
@ -456,7 +456,7 @@ public class ColumnFamilyRecordReader extends RecordReader<ByteBuffer, SortedMap
|
|||
int n = 0;
|
||||
for (KeySlice row : rows)
|
||||
n += row.columns.size();
|
||||
logger.debug("read {} columns in {} rows for {} starting with {}",
|
||||
logger.trace("read {} columns in {} rows for {} starting with {}",
|
||||
new Object[]{ n, rows.size(), keyRange, lastColumn });
|
||||
|
||||
wideColumns = Iterators.peekingIterator(new WideColumnIterator(rows));
|
||||
|
|
|
|||
|
|
@ -156,10 +156,10 @@ public class CqlRecordReader extends RecordReader<Long, Row>
|
|||
|
||||
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<Long, Row>
|
|||
{
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<SSTableReader, Double> 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);
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ public abstract class SSTable
|
|||
}
|
||||
FileUtils.delete(desc.filenameFor(Component.SUMMARY));
|
||||
|
||||
logger.debug("Deleted {}", desc);
|
||||
logger.trace("Deleted {}", desc);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -296,7 +296,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
if (cardinality != null)
|
||||
cardinalities.add(cardinality);
|
||||
else
|
||||
logger.debug("Got a null cardinality estimator in: {}", sstable.getFilename());
|
||||
logger.trace("Got a null cardinality estimator in: {}", sstable.getFilename());
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
|
|
@ -312,7 +312,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
return 1;
|
||||
|
||||
long totalKeyCountAfter = mergeCardinalities(cardinalities).cardinality();
|
||||
logger.debug("Estimated compaction gain: {}/{}={}", totalKeyCountAfter, totalKeyCountBefore, ((double)totalKeyCountAfter)/totalKeyCountBefore);
|
||||
logger.trace("Estimated compaction gain: {}/{}={}", totalKeyCountAfter, totalKeyCountBefore, ((double)totalKeyCountAfter)/totalKeyCountBefore);
|
||||
return ((double)totalKeyCountAfter)/totalKeyCountBefore;
|
||||
}
|
||||
|
||||
|
|
@ -399,7 +399,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
System.exit(1);
|
||||
}
|
||||
|
||||
logger.info("Opening {} ({} bytes)", descriptor, new File(descriptor.filenameFor(Component.DATA)).length());
|
||||
logger.debug("Opening {} ({} bytes)", descriptor, new File(descriptor.filenameFor(Component.DATA)).length());
|
||||
SSTableReader sstable = internalOpen(descriptor, components, metadata, partitioner, System.currentTimeMillis(),
|
||||
statsMetadata, OpenReason.NORMAL);
|
||||
|
||||
|
|
@ -446,7 +446,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
System.exit(1);
|
||||
}
|
||||
|
||||
logger.info("Opening {} ({} bytes)", descriptor, new File(descriptor.filenameFor(Component.DATA)).length());
|
||||
logger.debug("Opening {} ({} bytes)", descriptor, new File(descriptor.filenameFor(Component.DATA)).length());
|
||||
SSTableReader sstable = internalOpen(descriptor, components, metadata, partitioner, System.currentTimeMillis(),
|
||||
statsMetadata, OpenReason.NORMAL);
|
||||
try
|
||||
|
|
@ -454,14 +454,14 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
// load index and filter
|
||||
long start = System.nanoTime();
|
||||
sstable.load(validationMetadata);
|
||||
logger.debug("INDEX LOAD TIME for {}: {} ms.", descriptor, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start));
|
||||
logger.trace("INDEX LOAD TIME for {}: {} ms.", descriptor, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start));
|
||||
|
||||
sstable.setup(trackHotness);
|
||||
if (validate)
|
||||
sstable.validate();
|
||||
|
||||
if (sstable.getKeyCache() != null)
|
||||
logger.debug("key cache contains {}/{} keys", sstable.getKeyCache().size(), sstable.getKeyCache().getCapacity());
|
||||
logger.trace("key cache contains {}/{} keys", sstable.getKeyCache().size(), sstable.getKeyCache().getCapacity());
|
||||
|
||||
return sstable;
|
||||
}
|
||||
|
|
@ -843,7 +843,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
{
|
||||
if (indexSummary != null)
|
||||
indexSummary.close();
|
||||
logger.debug("Cannot deserialize SSTable Summary File {}: {}", summariesFile.getPath(), e.getMessage());
|
||||
logger.trace("Cannot deserialize SSTable Summary File {}: {}", summariesFile.getPath(), e.getMessage());
|
||||
// corrupted; delete it and fall back to creating a new summary
|
||||
FileUtils.closeQuietly(iStream);
|
||||
// delete it and fall back to creating a new summary
|
||||
|
|
@ -945,7 +945,7 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
logger.debug("Cannot save SSTable Summary: ", e);
|
||||
logger.trace("Cannot save SSTable Summary: ", e);
|
||||
|
||||
// corrupted hence delete it and let it load it now.
|
||||
if (summariesFile.exists())
|
||||
|
|
@ -1633,8 +1633,8 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
*/
|
||||
public boolean markObsolete(Tracker tracker)
|
||||
{
|
||||
if (logger.isDebugEnabled())
|
||||
logger.debug("Marking {} compacted", getFilename());
|
||||
if (logger.isTraceEnabled())
|
||||
logger.trace("Marking {} compacted", getFilename());
|
||||
|
||||
synchronized (tidy.global)
|
||||
{
|
||||
|
|
@ -1655,8 +1655,8 @@ public abstract class SSTableReader extends SSTable implements SelfRefCounted<SS
|
|||
|
||||
public void markSuspect()
|
||||
{
|
||||
if (logger.isDebugEnabled())
|
||||
logger.debug("Marking {} as a suspect for blacklisting.", getFilename());
|
||||
if (logger.isTraceEnabled())
|
||||
logger.trace("Marking {} as a suspect for blacklisting.", getFilename());
|
||||
|
||||
isSuspect.getAndSet(true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,11 +78,11 @@ public class MetadataSerializer implements IMetadataSerializer
|
|||
public Map<MetadataType, MetadataComponent> deserialize(Descriptor descriptor, EnumSet<MetadataType> types) throws IOException
|
||||
{
|
||||
Map<MetadataType, MetadataComponent> 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<MetadataType, MetadataComponent> 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<MetadataType, MetadataComponent> currentComponents = deserialize(descriptor, EnumSet.allOf(MetadataType.class));
|
||||
StatsMetadata stats = (StatsMetadata) currentComponents.remove(MetadataType.STATS);
|
||||
// mutate level
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -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<InetAddress, String[]> 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;
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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() ? "<empty>" : printPendingRanges()));
|
||||
if (logger.isTraceEnabled())
|
||||
logger.trace("Pending ranges:\n{}", (pendingRanges.isEmpty() ? "<empty>" : printPendingRanges()));
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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()));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -109,8 +109,8 @@ public class ReadCallback<TMessage, TResolved> 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<TMessage, TResolved> 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<TMessage, TResolved> 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();
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<String, List<String>> 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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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(),
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ public interface OutputHandler
|
|||
|
||||
public void debug(String msg)
|
||||
{
|
||||
logger.debug(msg);
|
||||
logger.trace(msg);
|
||||
}
|
||||
|
||||
public void warn(String msg)
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ public class TopKSampler<T>
|
|||
hll.offerHashed(hash);
|
||||
} catch (Exception e)
|
||||
{
|
||||
logger.debug("Failure to offer sample", e);
|
||||
logger.trace("Failure to offer sample", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue