IntenseFinance/nosqlbench
3
0
Fork 0
mirror of https://github.com/nosqlbench/nosqlbench.git synced 2025-02-25 18:55:28 -06:00
Code Issues Packages Projects Releases Wiki Activity

consolidate to log4j2

Browse Source
This commit is contained in:
Jonathan Shook
2020-11-16 17:30:20 -06:00
parent 6a523dc484
commit a09efbe994
187 changed files with 1153 additions and 756 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/core/BaseAsyncAction.java
View File

@@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityapi.core;
import io.nosqlbench.engine.api.activityapi.core.ops.fluent.opfacets.TrackedOp;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.ParameterMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
*
@@ -29,7 +29,7 @@ import org.slf4j.LoggerFactory;
* @param <A> An type of of an Activity, a state holder for a runtime instance of an Activity
*/
public abstract class BaseAsyncAction<D, A extends Activity> implements AsyncAction<D>, Stoppable, ActivityDefObserver {
private final static Logger logger = LoggerFactory.getLogger("BaseAsyncAction");
private final static Logger logger = LogManager.getLogger("BaseAsyncAction");
protected final A activity;

12
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/buffers/results_rle/CycleResultsRLEBufferTarget.java
View File

@@ -21,8 +21,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.nio.ByteBuffer;
import java.util.function.Predicate;
@@ -40,7 +40,7 @@ import java.util.function.Predicate;
* will be deemed invalid and will cause an exception to be thrown.
*/
public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(CycleResultsRLEBufferTarget.class);
private final static Logger logger = LogManager.getLogger(CycleResultsRLEBufferTarget.class);
public final static int BYTES = Long.BYTES + Long.BYTES + Byte.BYTES;
@@ -49,8 +49,8 @@ public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue
private long lastResult = Integer.MIN_VALUE;
private long runlength = 0L;
private boolean flushed = false;
private long count=0L;
private long min=Long.MAX_VALUE;
private final long count=0L;
private final long min=Long.MAX_VALUE;
private Predicate<ResultReadable> filter;
/**
@@ -147,7 +147,7 @@ public class CycleResultsRLEBufferTarget implements Output,CanFilterResultValue
}
private static class ResultReadableWrapper implements ResultReadable {
private int result;
private final int result;
ResultReadableWrapper(int result) {
this.result = result;
}

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/filters/tristate/EnumReadableMappingFilter.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.activityapi.cyclelog.filters.tristate;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.regex.Pattern;
@@ -31,10 +31,10 @@ import java.util.regex.Pattern;
* @param <E> The type of the Enum which implements TristateFilter
*/
public class EnumReadableMappingFilter<E extends Enum<E> & ResultReadable> implements TristateFilter<ResultReadable> {
private final static Logger logger = LoggerFactory.getLogger(EnumReadableMappingFilter.class);
private final static Logger logger = LogManager.getLogger(EnumReadableMappingFilter.class);
private final E[] enumValues;
private ResultMappingArrayFilter arrayFilter = new ResultMappingArrayFilter();
private final ResultMappingArrayFilter arrayFilter = new ResultMappingArrayFilter();
public EnumReadableMappingFilter(E[] enumValues, Policy defaultPolicy) {
this.enumValues = enumValues;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/inputs/cyclelog/CycleLogInput.java
View File

@@ -27,8 +27,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results_rle.CycleRe
import io.nosqlbench.engine.api.activityapi.input.Input;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.RandomAccessFile;
@@ -38,7 +38,7 @@ import java.util.Iterator;
import java.util.function.Predicate;
public class CycleLogInput implements Input, AutoCloseable, Iterable<CycleResultsSegment>, CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(CycleLogInput.class);
private final static Logger logger = LogManager.getLogger(CycleLogInput.class);
private final Iterator<CycleResultsSegment> cycleResultSegmentIterator;
private RandomAccessFile raf;
private MappedByteBuffer mbb;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/ReorderingConcurrentResultBuffer.java
View File

@@ -23,8 +23,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReadable;
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Collections;
import java.util.LinkedList;
@@ -36,10 +36,10 @@ import java.util.function.Predicate;
*/
public class ReorderingConcurrentResultBuffer implements Output, CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(ReorderingConcurrentResultBuffer.class);
private final static Logger logger = LogManager.getLogger(ReorderingConcurrentResultBuffer.class);
private LinkedList<CycleResultsSegment> segments = new LinkedList<>();
private Output downstream;
private final LinkedList<CycleResultsSegment> segments = new LinkedList<>();
private final Output downstream;
private final int threshold;
private int currentCount;
private int segmentCount;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/cyclelog/CycleLogOutput.java
View File

@@ -26,8 +26,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results_rle.CycleSp
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.util.SimpleConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.RandomAccessFile;
@@ -51,13 +51,13 @@ import java.util.function.Predicate;
public class CycleLogOutput implements Output, CanFilterResultValue {
// For use in allocating file data, etc
private final static Logger logger = LoggerFactory.getLogger(CycleLogOutput.class);
private final static Logger logger = LogManager.getLogger(CycleLogOutput.class);
private MappedByteBuffer mbb;
private RandomAccessFile file;
// private FileBufferConfig config;
private CycleResultsRLEBufferTarget targetBuffer;
private int extentSizeInSpans;
private File outputFile;
private final int extentSizeInSpans;
private final File outputFile;
private Predicate<ResultReadable> filter;
public CycleLogOutput(Activity activity) {

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/cyclelog/CycleLogOutputType.java
View File

@@ -24,8 +24,8 @@ import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityapi.output.OutputDispenser;
import io.nosqlbench.engine.api.activityapi.output.OutputType;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@Service(OutputType.class)
public class CycleLogOutputType implements OutputType {
@@ -41,10 +41,10 @@ public class CycleLogOutputType implements OutputType {
}
public static class Dispenser implements OutputDispenser {
private final static Logger logger = LoggerFactory.getLogger(OutputDispenser.class);
private final static Logger logger = LogManager.getLogger(OutputDispenser.class);
private final Output output;
private Activity activity;
private final Activity activity;
public Dispenser(Activity activity) {
this.activity = activity;

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/logger/LoggingMarkerDispenser.java
View File

@@ -21,14 +21,14 @@ import io.nosqlbench.engine.api.activityapi.core.Activity;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityapi.output.OutputDispenser;
import io.nosqlbench.nb.annotations.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
@Service(OutputDispenser.class)
public class LoggingMarkerDispenser implements OutputDispenser {
private final static Logger logger = LoggerFactory.getLogger(LoggingMarkerDispenser.class);
private Activity activity;
private final static Logger logger = LogManager.getLogger(LoggingMarkerDispenser.class);
private final Activity activity;
public LoggingMarkerDispenser(Activity activity) {
this.activity = activity;

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/cyclelog/outputs/logger/LoggingOutput.java
View File

@@ -21,13 +21,13 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.ResultReada
import io.nosqlbench.engine.api.activityapi.cyclelog.inputs.cyclelog.CanFilterResultValue;
import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.function.Predicate;
public class LoggingOutput implements Output,CanFilterResultValue {
private final static Logger logger = LoggerFactory.getLogger(LoggingOutput.class);
private final static Logger logger = LogManager.getLogger(LoggingOutput.class);
private final ActivityDef def;
private final long slot;
@@ -63,7 +63,7 @@ public class LoggingOutput implements Output,CanFilterResultValue {
}
private static class ResultReadableWrapper implements ResultReadable {
private int result;
private final int result;
public ResultReadableWrapper(int result) {
this.result = result;
}

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/errorhandling/CycleErrorHandlers.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.errorhandling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
@@ -27,7 +27,7 @@ import java.util.List;
*/
public class CycleErrorHandlers {
private final static Logger logger = LoggerFactory.getLogger(CycleErrorHandlers.class);
private final static Logger logger = LogManager.getLogger(CycleErrorHandlers.class);
public static <T extends Throwable, R> CycleErrorHandler<T, R> log(R result) {
return (cycle, error, errMsg) -> {

12
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/errorhandling/HashedErrorHandler.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.errorhandling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
@@ -59,15 +59,15 @@ import java.util.stream.Collectors;
* @param <R> The result type that will be produced by these error handlers.
*/
public class HashedErrorHandler<T extends Throwable, R> implements CycleErrorHandler<T, R> {
private final static Logger logger = LoggerFactory.getLogger(HashedErrorHandler.class);
private final static Logger logger = LogManager.getLogger(HashedErrorHandler.class);
private final CycleErrorHandler<T, R> DEFAULT_defaultHandler = (cycle, error, errMsg) -> {
throw new RuntimeException("no handler defined for type " + error.getClass() + " in cycle " + cycle + ", " + errMsg);
};
private Class<? extends Throwable> upperBound = Throwable.class;
private Map<String, Set<Class<? extends T>>> errorGroups = new ConcurrentHashMap<>();
private Map<Class<? extends T>, CycleErrorHandler<T, R>> handlers = new ConcurrentHashMap<>();
private Set<Class<? extends T>> validClasses = new HashSet<>();
private final Map<String, Set<Class<? extends T>>> errorGroups = new ConcurrentHashMap<>();
private final Map<Class<? extends T>, CycleErrorHandler<T, R>> handlers = new ConcurrentHashMap<>();
private final Set<Class<? extends T>> validClasses = new HashSet<>();
private CycleErrorHandler<T, R> defaultHandler = DEFAULT_defaultHandler;
/**

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/planning/SequencePlanner.java
View File

@@ -17,15 +17,15 @@
package io.nosqlbench.engine.api.activityapi.planning;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
import java.util.function.ToLongFunction;
public class SequencePlanner<T> {
private final static Logger logger = LoggerFactory.getLogger(SequencePlanner.class);
private final static Logger logger = LogManager.getLogger(SequencePlanner.class);
private final SequencerType sequencerType;
private List<T> elements = new ArrayList<>();
private final List<Long> ratios = new ArrayList<>();

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/HybridRateLimiter.java
View File

@@ -21,8 +21,8 @@ import com.codahale.metrics.Gauge;
import io.nosqlbench.engine.api.activityapi.core.Startable;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.atomic.AtomicLong;
@@ -78,7 +78,7 @@ import java.util.concurrent.atomic.AtomicLong;
*/
public class HybridRateLimiter implements Startable, RateLimiter {
private final static Logger logger = LoggerFactory.getLogger(HybridRateLimiter.class);
private final static Logger logger = LogManager.getLogger(HybridRateLimiter.class);
private volatile TokenFiller filler;
private volatile long starttime;
@@ -98,7 +98,7 @@ public class HybridRateLimiter implements Startable, RateLimiter {
// diagnostics
// TODO Doc rate limiter scenarios, including when you want to reset the waittime, and when you don't
private AtomicLong cumulativeWaitTimeNanos = new AtomicLong(0L);
private final AtomicLong cumulativeWaitTimeNanos = new AtomicLong(0L);
protected HybridRateLimiter() {
}

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateLimiters.java
View File

@@ -19,11 +19,11 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import com.codahale.metrics.Gauge;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class RateLimiters {
private final static Logger logger = LoggerFactory.getLogger(RateLimiters.class);
private final static Logger logger = LogManager.getLogger(RateLimiters.class);
public static synchronized RateLimiter createOrUpdate(ActivityDef def, String label, RateLimiter extant, RateSpec spec) {

11
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/RateSpec.java
View File

@@ -19,8 +19,8 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import io.nosqlbench.engine.api.activityimpl.ParameterMap;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* <H2>Rate Limiter Specifications</H2>
@@ -101,7 +101,7 @@ import org.slf4j.LoggerFactory;
*/
public class RateSpec {
private final static Logger logger = LoggerFactory.getLogger(RateSpec.class);
private final static Logger logger = LogManager.getLogger(RateSpec.class);
public static final double DEFAULT_RATE_OPS_S = 1.0D;
public static final double DEFAULT_BURST_RATIO = 1.1D;
@@ -114,7 +114,7 @@ public class RateSpec {
public double burstRatio = DEFAULT_BURST_RATIO;
public Verb verb = Verb.start;
public static enum Verb {
public enum Verb {
/**
* Specify that a rate limiter should only be configured without affecting its running state.
* If the rate limiter is already running, then the configuration should take effect immediately.
@@ -223,8 +223,7 @@ public class RateSpec {
RateSpec rateSpec = (RateSpec) o;
if (Double.compare(rateSpec.opsPerSec, opsPerSec) != 0) return false;
if (Double.compare(rateSpec.burstRatio, burstRatio) != 0) return false;
return true;
return Double.compare(rateSpec.burstRatio, burstRatio) == 0;
}
@Override

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/TokenFiller.java
View File

@@ -20,14 +20,14 @@ package io.nosqlbench.engine.api.activityapi.ratelimits;
import com.codahale.metrics.Timer;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
public class TokenFiller implements Runnable {
private final static Logger logger = LoggerFactory.getLogger(TokenFiller.class);
private final static Logger logger = LogManager.getLogger(TokenFiller.class);
public final static double MIN_PER_SECOND = 10D;
public final static double MAX_PER_SECOND = 1000D;
@@ -40,7 +40,7 @@ public class TokenFiller implements Runnable {
private RateSpec rateSpec;
private Thread thread;
private volatile long lastRefillAt;
private Timer timer;
private final Timer timer;
/**
* A token filler adds tokens to a {@link TokenPool} at some rate.

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/ratelimits/TokenPool.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.ratelimits;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import static io.nosqlbench.engine.api.util.Colors.*;
@@ -44,7 +44,7 @@ import static io.nosqlbench.engine.api.util.Colors.*;
*/
public class TokenPool {
private final static Logger logger = LoggerFactory.getLogger(TokenPool.class);
private final static Logger logger = LogManager.getLogger(TokenPool.class);
public static final double MIN_CONCURRENT_OPS = 2;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/sysperf/SysPerf.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityapi.sysperf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.yaml.snakeyaml.Yaml;
import java.io.File;
@@ -31,7 +31,7 @@ import java.nio.file.attribute.FileTime;
import java.util.Optional;
public class SysPerf {
public final static Logger logger = LoggerFactory.getLogger(SysPerf.class);
public final static Logger logger = LogManager.getLogger(SysPerf.class);
private static final Charset CHARSET = StandardCharsets.UTF_8;
private static SysPerfData cachedData;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityapi/sysperf/SysPerfBaseliner.java
View File

@@ -21,8 +21,8 @@ import org.openjdk.jmh.results.RunResult;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.nio.file.Files;
import java.util.ArrayList;
@@ -32,7 +32,7 @@ import java.util.Map;
public class SysPerfBaseliner {
private final static Logger logger = LoggerFactory.getLogger(SysPerfBaseliner.class);
private final static Logger logger = LogManager.getLogger(SysPerfBaseliner.class);
public static void main(String[] args) {
try {

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/ParsedStmt.java
View File

@@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityconfig;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtDef;
import io.nosqlbench.virtdata.core.templates.BindPoint;
import io.nosqlbench.virtdata.core.templates.ParsedTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.Map;
@@ -39,7 +39,7 @@ import java.util.regex.Pattern;
public class ParsedStmt {
private final static Pattern stmtToken = Pattern.compile("\\?(\\w+[-_\\d\\w]*)|\\{(\\w+[-_\\d\\w.]*)}");
private final static Logger logger = LoggerFactory.getLogger(ParsedStmt.class);
private final static Logger logger = LogManager.getLogger(ParsedStmt.class);
private ParsedTemplate template;
private final StmtDef stmtDef;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/StatementsLoader.java
View File

@@ -22,15 +22,15 @@ import io.nosqlbench.engine.api.activityconfig.rawyaml.RawStmtsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.nb.api.content.Content;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Map;
import java.util.function.Function;
public class StatementsLoader {
private final static Logger logger = LoggerFactory.getLogger(StatementsLoader.class);
private final static Logger logger = LogManager.getLogger(StatementsLoader.class);
public enum Loader {
original,

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/rawyaml/RawStmtFields.java
View File

@@ -18,15 +18,15 @@
package io.nosqlbench.engine.api.activityconfig.rawyaml;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
public class RawStmtFields extends Tags {
private final static Logger logger = LoggerFactory.getLogger(RawStmtFields.class);
private final static Logger logger = LogManager.getLogger(RawStmtFields.class);
private String name = "";
private String desc = "";

2
engine-api/src/main/java/io/nosqlbench/engine/api/activityconfig/rawyaml/RawStmtsLoader.java
View File

@@ -4,7 +4,7 @@ import io.nosqlbench.engine.api.activityimpl.ActivityInitializationError;
import io.nosqlbench.nb.api.content.Content;
import io.nosqlbench.nb.api.content.NBIO;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.apache.logging.log4j.Logger;
import org.yaml.snakeyaml.Yaml;
import java.util.*;

10
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/ActivityDef.java
View File

@@ -19,8 +19,8 @@
package io.nosqlbench.engine.api.activityimpl;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.Optional;
@@ -43,7 +43,7 @@ public class ActivityDef {
public static final String DEFAULT_ATYPE = "stdout ";
public static final String DEFAULT_CYCLES = "0";
public static final int DEFAULT_THREADS = 1;
private final static Logger logger = LoggerFactory.getLogger(ActivityDef.class);
private final static Logger logger = LogManager.getLogger(ActivityDef.class);
// an alias with which to control the activity while it is running
private static final String FIELD_ALIAS = "alias";
// a file or URL containing the activity: statements, generator bindings, ...
@@ -52,11 +52,11 @@ public class ActivityDef {
private static final String FIELD_CYCLES = "cycles";
// initial thread concurrency for this activity
private static final String FIELD_THREADS = "threads";
private static String[] field_list = new String[]{
private static final String[] field_list = new String[]{
FIELD_ALIAS, FIELD_ATYPE, FIELD_CYCLES, FIELD_THREADS
};
// parameter map has its own internal atomic map
private ParameterMap parameterMap;
private final ParameterMap parameterMap;
public ActivityDef(ParameterMap parameterMap) {
this.parameterMap = parameterMap;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/CpuInfo.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityimpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.HardwareAbstractionLayer;
@@ -27,7 +27,7 @@ import java.util.DoubleSummaryStatistics;
import java.util.Optional;
public class CpuInfo {
private final static Logger logger = LoggerFactory.getLogger(CpuInfo.class);
private final static Logger logger = LogManager.getLogger(CpuInfo.class);
final private static SystemInfo SYSTEM_INFO = new SystemInfo();

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/ParameterMap.java
View File

@@ -15,13 +15,13 @@
package io.nosqlbench.engine.api.activityimpl;
import io.nosqlbench.engine.api.activityimpl.motor.ParamsParser;
import io.nosqlbench.nb.api.config.ParamsParser;
import io.nosqlbench.engine.api.util.Unit;
import org.graalvm.polyglot.Value;
import org.graalvm.polyglot.proxy.ProxyObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.script.Bindings;
import java.util.*;
@@ -42,7 +42,7 @@ import java.util.stream.Collectors;
* generic type is parameterized for Bindings support.</p>
*/
public class ParameterMap extends ConcurrentHashMap<String,Object> implements Bindings, ProxyObject {
private final static Logger logger = LoggerFactory.getLogger(ParameterMap.class);
private final static Logger logger = LogManager.getLogger(ParameterMap.class);
// private final ConcurrentHashMap<String, String> paramMap = new ConcurrentHashMap<>(10);

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/SimpleActivity.java
View File

@@ -20,8 +20,8 @@ import io.nosqlbench.engine.api.metrics.ActivityMetrics;
import io.nosqlbench.engine.api.templating.CommandTemplate;
import io.nosqlbench.engine.api.templating.StrInterpolator;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.InputStream;
import java.io.PrintWriter;
@@ -35,7 +35,7 @@ import java.util.function.Supplier;
* A default implementation of an Activity, suitable for building upon.
*/
public class SimpleActivity implements Activity, ProgressCapable {
private final static Logger logger = LoggerFactory.getLogger("ACTIVITY");
private final static Logger logger = LogManager.getLogger("ACTIVITY");
protected ActivityDef activityDef;
private final List<AutoCloseable> closeables = new ArrayList<>();

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/SlotStateTracker.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.activityimpl;
import io.nosqlbench.engine.api.activityapi.core.RunState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.atomic.AtomicReference;
@@ -29,7 +29,7 @@ import java.util.concurrent.atomic.AtomicReference;
*/
public class SlotStateTracker {
private final AtomicReference<RunState> slotState = new AtomicReference<>(RunState.Uninitialized);
private final static Logger logger = LoggerFactory.getLogger(SlotStateTracker.class);
private final static Logger logger = LogManager.getLogger(SlotStateTracker.class);
private final long slotId;
public SlotStateTracker(long slotId) {

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/action/CoreAction.java
View File

@@ -19,11 +19,11 @@ package io.nosqlbench.engine.api.activityimpl.action;
import io.nosqlbench.engine.api.activityapi.core.SyncAction;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class CoreAction implements SyncAction {
private final static Logger logger = LoggerFactory.getLogger(CoreAction.class);
private final static Logger logger = LogManager.getLogger(CoreAction.class);
private final int interval;
private final int slot;

8
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/action/CoreActionDispenser.java
View File

@@ -19,17 +19,17 @@ package io.nosqlbench.engine.api.activityimpl.action;
import io.nosqlbench.engine.api.activityapi.core.Action;
import io.nosqlbench.engine.api.activityapi.core.ActionDispenser;
import io.nosqlbench.engine.api.activityapi.core.Activity;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* An action dispenser that returns a logging action.
*/
public class CoreActionDispenser implements ActionDispenser {
private final static Logger logger = LoggerFactory.getLogger(CoreActionDispenser.class);
private final static Logger logger = LogManager.getLogger(CoreActionDispenser.class);
private Activity activity;
private final Activity activity;
public CoreActionDispenser(Activity activity) {
this.activity = activity;

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/input/AtomicInput.java
View File

@@ -22,8 +22,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleSegmen
import io.nosqlbench.engine.api.activityapi.input.Input;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.concurrent.atomic.AtomicLong;
@@ -43,7 +43,7 @@ import java.util.concurrent.atomic.AtomicLong;
* caller to check the value to determine when the input is deemed "used up."</p>
*/
public class AtomicInput implements Input, ActivityDefObserver, ProgressCapable {
private final static Logger logger = LoggerFactory.getLogger(AtomicInput.class);
private final static Logger logger = LogManager.getLogger(AtomicInput.class);
private final AtomicLong cycleValue = new AtomicLong(0L);
private final AtomicLong min = new AtomicLong(0L);

20
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/marker/ContiguousOutputChunker.java
View File

@@ -22,8 +22,8 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResultsIntervalSegment;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResultsSegment;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.ArrayList;
import java.util.List;
@@ -53,16 +53,16 @@ import java.util.concurrent.locks.ReentrantLock;
*/
public class ContiguousOutputChunker implements Output {
private final static Logger logger = LoggerFactory.getLogger(ContiguousOutputChunker.class);
private final static Logger logger = LogManager.getLogger(ContiguousOutputChunker.class);
private final int extentSize;
private final int maxExtents;
private List<Output> readers = new ArrayList<>();
private AtomicLong min;
private AtomicLong nextMin;
private AtomicReference<ByteTrackerExtent> markingExtents = new AtomicReference<>();
private ReentrantLock lock = new ReentrantLock(false);
private Condition nowMarking = lock.newCondition();
private Semaphore mutex = new Semaphore(1, false);
private final List<Output> readers = new ArrayList<>();
private final AtomicLong min;
private final AtomicLong nextMin;
private final AtomicReference<ByteTrackerExtent> markingExtents = new AtomicReference<>();
private final ReentrantLock lock = new ReentrantLock(false);
private final Condition nowMarking = lock.newCondition();
private final Semaphore mutex = new Semaphore(1, false);
public ContiguousOutputChunker(long min, long nextRangeMin, int extentSize, int maxExtents) {
this.min = new AtomicLong(min);

16
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/CoreMotor.java
View File

@@ -31,8 +31,8 @@ import io.nosqlbench.engine.api.activityapi.output.Output;
import io.nosqlbench.engine.api.activityapi.ratelimits.RateLimiter;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.activityimpl.SlotStateTracker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
@@ -52,9 +52,9 @@ import static io.nosqlbench.engine.api.activityapi.core.RunState.*;
*/
public class CoreMotor<D> implements ActivityDefObserver, Motor<D>, Stoppable {
private static final Logger logger = LoggerFactory.getLogger(CoreMotor.class);
private static final Logger logger = LogManager.getLogger(CoreMotor.class);
private long slotId;
private final long slotId;
private Timer inputTimer;
@@ -71,11 +71,11 @@ public class CoreMotor<D> implements ActivityDefObserver, Motor<D>, Stoppable {
private Input input;
private Action action;
private Activity activity;
private final Activity activity;
private Output output;
private SlotStateTracker slotStateTracker;
private AtomicReference<RunState> slotState;
private final SlotStateTracker slotStateTracker;
private final AtomicReference<RunState> slotState;
private int stride = 1;
private OpTracker<D> opTracker;
@@ -237,7 +237,7 @@ public class CoreMotor<D> implements ActivityDefObserver, Motor<D>, Stoppable {
@SuppressWarnings("unchecked")
AsyncAction<D> async = AsyncAction.class.cast(action);
AsyncAction<D> async = (AsyncAction) action;
opTracker = new OpTrackerImpl<>(activity, slotId);
opTracker.setCycleOpFunction(async.getOpInitFunction());

6
engine-api/src/main/java/io/nosqlbench/engine/api/activityimpl/motor/StrideTracker.java
View File

@@ -24,15 +24,15 @@ import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.op_output.StrideOut
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResult;
import io.nosqlbench.engine.api.activityapi.cyclelog.buffers.results.CycleResultsSegment;
import io.nosqlbench.engine.api.activityapi.output.Output;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class StrideTracker<D> extends Buffer<CompletedOp<D>> implements OpEvents<D>, CycleResultsSegment {
private final static Logger logger = LoggerFactory.getLogger(StrideTracker.class);
private final static Logger logger = LogManager.getLogger(StrideTracker.class);
private final Timer strideServiceTimer;
private final Timer strideResponseTimer;

2
engine-api/src/main/java/io/nosqlbench/engine/api/extensions/ScriptingPluginInfo.java
View File

@@ -18,7 +18,7 @@
package io.nosqlbench.engine.api.extensions;
import com.codahale.metrics.MetricRegistry;
import org.slf4j.Logger;
import org.apache.logging.log4j.Logger;
import javax.script.ScriptContext;

10
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/ActivityMetrics.java
View File

@@ -21,8 +21,8 @@ import com.codahale.metrics.*;
import io.nosqlbench.engine.api.activityapi.core.MetricRegistryService;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import io.nosqlbench.engine.api.util.Unit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.script.ScriptContext;
import java.io.File;
@@ -35,7 +35,7 @@ import java.util.regex.Pattern;
public class ActivityMetrics {
private final static Logger logger = LoggerFactory.getLogger(ActivityMetrics.class);
private final static Logger logger = LogManager.getLogger(ActivityMetrics.class);
public static final String HDRDIGITS_PARAM = "hdr_digits";
public static final int DEFAULT_HDRDIGITS= 4;
@@ -46,7 +46,7 @@ public class ActivityMetrics {
public static MetricFilter METRIC_FILTER = (name, metric) -> {
return true;
};
private static List<MetricsCloseable> metricsCloseables = new ArrayList<>();
private static final List<MetricsCloseable> metricsCloseables = new ArrayList<>();
public static int getHdrDigits() {
@@ -305,7 +305,7 @@ public class ActivityMetrics {
}
}
private static interface MetricProvider {
private interface MetricProvider {
Metric getMetric();
}

18
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/ClassicHistoListener.java
View File

@@ -1,8 +1,8 @@
package io.nosqlbench.engine.api.metrics;
import com.codahale.metrics.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.HashMap;
import java.util.Map;
@@ -10,15 +10,15 @@ import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
public class ClassicHistoListener extends CapabilityHook<HistogramAttachment> {
private final static Logger logger = LoggerFactory.getLogger(ClassicHistoListener.class);
private final static Logger logger = LogManager.getLogger(ClassicHistoListener.class);
private final MetricRegistry metricsRegistry;
private String sessionName;
private String prefix;
private Pattern pattern;
private String interval;
private TimeUnit nanoseconds;
private Map<String, Attachment> histos = new HashMap<>();
private final String sessionName;
private final String prefix;
private final Pattern pattern;
private final String interval;
private final TimeUnit nanoseconds;
private final Map<String, Attachment> histos = new HashMap<>();
public ClassicHistoListener(MetricRegistry metricRegistry, String sessionName, String prefix, Pattern pattern, String interval, TimeUnit nanoseconds) {
this.metricsRegistry = metricRegistry;

18
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/ClassicTimerListener.java
View File

@@ -3,8 +3,8 @@ package io.nosqlbench.engine.api.metrics;
import com.codahale.metrics.ExponentiallyDecayingReservoir;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.HashMap;
import java.util.Map;
@@ -12,15 +12,15 @@ import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
public class ClassicTimerListener extends CapabilityHook<TimerAttachment> {
private final static Logger logger = LoggerFactory.getLogger(ClassicTimerListener.class);
private final static Logger logger = LogManager.getLogger(ClassicTimerListener.class);
private final MetricRegistry metricsRegistry;
private String sessionName;
private String prefix;
private Pattern pattern;
private String interval;
private TimeUnit nanoseconds;
private Map<String, Attachment> histos = new HashMap<>();
private final String sessionName;
private final String prefix;
private final Pattern pattern;
private final String interval;
private final TimeUnit nanoseconds;
private final Map<String, Attachment> histos = new HashMap<>();
public ClassicTimerListener(MetricRegistry metricRegistry, String sessionName, String prefix, Pattern pattern, String interval, TimeUnit nanoseconds) {
this.metricsRegistry = metricRegistry;

8
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/DeltaHdrHistogramReservoir.java
View File

@@ -22,8 +22,8 @@ import com.codahale.metrics.Snapshot;
import org.HdrHistogram.Histogram;
import org.HdrHistogram.HistogramLogWriter;
import org.HdrHistogram.Recorder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* A custom wrapping of snapshotting logic on the HdrHistogram. This histogram will always report the last histogram
@@ -36,14 +36,14 @@ import org.slf4j.LoggerFactory;
*
*/
public final class DeltaHdrHistogramReservoir implements Reservoir {
private final static Logger logger = LoggerFactory.getLogger(DeltaHdrHistogramReservoir.class);
private final static Logger logger = LogManager.getLogger(DeltaHdrHistogramReservoir.class);
private final Recorder recorder;
private Histogram lastHistogram;
private Histogram intervalHistogram;
private long intervalHistogramEndTime = System.currentTimeMillis();
private String metricName;
private final String metricName;
private HistogramLogWriter writer;
/**

14
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/HistoIntervalLogger.java
View File

@@ -19,8 +19,8 @@ package io.nosqlbench.engine.api.metrics;
import org.HdrHistogram.EncodableHistogram;
import org.HdrHistogram.HistogramLogWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.FileNotFoundException;
@@ -36,22 +36,22 @@ import java.util.regex.Pattern;
* logfile at the configured interval.
*/
public class HistoIntervalLogger extends CapabilityHook<HdrDeltaHistogramAttachment> implements Runnable, MetricsCloseable {
private final static Logger logger = LoggerFactory.getLogger(HistoIntervalLogger.class);
private final static Logger logger = LogManager.getLogger(HistoIntervalLogger.class);
private final String sessionName;
// private final long intervalMillis;
private long intervalLength;
private final long intervalLength;
public File getLogfile() {
return logfile;
}
private File logfile;
private final File logfile;
private PrintStream logStream;
private HistogramLogWriter writer;
private Pattern pattern;
private final Pattern pattern;
private List<WriterTarget> targets = new CopyOnWriteArrayList<>();
private final List<WriterTarget> targets = new CopyOnWriteArrayList<>();
private PeriodicRunnable<HistoIntervalLogger> executor;
private long lastRunTime;

8
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/HistoLogChartGenerator.java
View File

@@ -10,8 +10,8 @@ package io.nosqlbench.engine.api.metrics;
import com.mitchtalmadge.asciidata.graph.ASCIIGraph;
import org.HdrHistogram.HistogramLogReader;
import org.HdrHistogram.Histogram;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.io.FileNotFoundException;
@@ -29,8 +29,8 @@ public class HistoLogChartGenerator {
public static final String ANSI_CYAN = "\u001B[36m";
public static final String ANSI_WHITE = "\u001B[37m";
private static Map<String, ArrayList<Histogram>> histogramsOverTime = new HashMap<>();
private static Logger logger = LoggerFactory.getLogger(HistoLogChartGenerator.class);
private static final Map<String, ArrayList<Histogram>> histogramsOverTime = new HashMap<>();
private static final Logger logger = LogManager.getLogger(HistoLogChartGenerator.class);
public static void generateChartFromHistoLog(HistoIntervalLogger histoIntervalLogger) {
File logFile = histoIntervalLogger.getLogfile();

6
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/HistoStatsCSVWriter.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.metrics;
import org.HdrHistogram.Histogram;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.*;
import java.util.Date;
@@ -27,7 +27,7 @@ import java.util.Locale;
import java.util.concurrent.TimeUnit;
public class HistoStatsCSVWriter {
private final static Logger logger = LoggerFactory.getLogger(HistoStatsCSVWriter.class);
private final static Logger logger = LogManager.getLogger(HistoStatsCSVWriter.class);
private final static String logFormatVersion = "1.0";
private final File csvfile;
// FileWriter writer;

14
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/HistoStatsLogger.java
View File

@@ -19,8 +19,8 @@ package io.nosqlbench.engine.api.metrics;
import org.HdrHistogram.EncodableHistogram;
import org.HdrHistogram.Histogram;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.File;
import java.util.List;
@@ -36,17 +36,17 @@ import java.util.regex.Pattern;
*/
public class HistoStatsLogger extends CapabilityHook<HdrDeltaHistogramAttachment>
implements Runnable, MetricsCloseable {
private final static Logger logger = LoggerFactory.getLogger(HistoStatsLogger.class);
private final static Logger logger = LogManager.getLogger(HistoStatsLogger.class);
private final String sessionName;
private final TimeUnit timeUnit;
// private final long intervalMillis;
private long intervalLength;
private File logfile;
private final long intervalLength;
private final File logfile;
private HistoStatsCSVWriter writer;
private Pattern pattern;
private final Pattern pattern;
private List<WriterTarget> targets = new CopyOnWriteArrayList<>();
private final List<WriterTarget> targets = new CopyOnWriteArrayList<>();
private PeriodicRunnable<HistoStatsLogger> executor;
private long lastRunTime=0L;

10
engine-api/src/main/java/io/nosqlbench/engine/api/metrics/PeriodicRunnable.java
View File

@@ -17,17 +17,17 @@
package io.nosqlbench.engine.api.metrics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
/**
* This is a simple and light way to run a periodic task
*/
public class PeriodicRunnable<T extends Runnable> implements Runnable, AutoCloseable {
private static Logger logger = LoggerFactory.getLogger(PeriodicRunnable.class);
private static final Logger logger = LogManager.getLogger(PeriodicRunnable.class);
private long intervalMillis;
private T action;
private final long intervalMillis;
private final T action;
private Thread thread;
private volatile boolean running = false;

6
engine-api/src/main/java/io/nosqlbench/engine/api/scenarios/NBCLIScenarioParser.java
View File

@@ -9,8 +9,8 @@ import io.nosqlbench.nb.api.content.Content;
import io.nosqlbench.nb.api.content.NBIO;
import io.nosqlbench.nb.api.content.NBPathsAPI;
import io.nosqlbench.nb.api.errors.BasicError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.io.IOException;
import java.nio.file.FileSystems;
@@ -28,7 +28,7 @@ public class NBCLIScenarioParser {
public final static String VERBOSE_LOCKED = "===";
public final static String UNLOCKED = "=";
private final static Logger logger = LoggerFactory.getLogger(NBCLIScenarioParser.class);
private final static Logger logger = LogManager.getLogger(NBCLIScenarioParser.class);
private static final String SEARCH_IN = "activities";
public static final String WORKLOAD_SCENARIO_STEP = "WORKLOAD_SCENARIO_STEP";

6
engine-api/src/main/java/io/nosqlbench/engine/api/scripting/NashornEvaluator.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.scripting;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.script.*;
@@ -28,7 +28,7 @@ import javax.script.*;
* @param <T> generic parameter for return types from this evaluator
*/
public class NashornEvaluator<T> implements Evaluator<T> {
private final static Logger logger = LoggerFactory.getLogger(NashornEvaluator.class);
private final static Logger logger = LogManager.getLogger(NashornEvaluator.class);
private static final ScriptEngineManager engineManager = new ScriptEngineManager();
private final ScriptEngine scriptEngine;

8
engine-api/src/main/java/io/nosqlbench/engine/api/templating/CommandTemplate.java
View File

@@ -1,13 +1,13 @@
package io.nosqlbench.engine.api.templating;
import io.nosqlbench.engine.api.activityconfig.yaml.OpTemplate;
import io.nosqlbench.engine.api.activityimpl.motor.ParamsParser;
import io.nosqlbench.nb.api.config.ParamsParser;
import io.nosqlbench.virtdata.core.bindings.BindingsTemplate;
import io.nosqlbench.virtdata.core.templates.ParsedTemplate;
import io.nosqlbench.virtdata.core.templates.StringBindings;
import io.nosqlbench.virtdata.core.templates.StringBindingsTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.function.Function;
@@ -29,7 +29,7 @@ import java.util.function.Function;
*/
public class CommandTemplate {
private final static Logger logger = LoggerFactory.getLogger(CommandTemplate.class);
private final static Logger logger = LogManager.getLogger(CommandTemplate.class);
private final String name;
private final Map<String, String> statics = new HashMap<>();

6
engine-api/src/main/java/io/nosqlbench/engine/api/util/SSLKsFactory.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.util;
import io.nosqlbench.engine.api.activityimpl.ActivityDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
@@ -40,7 +40,7 @@ import java.util.Optional;
import java.util.regex.Pattern;
public class SSLKsFactory {
private final static Logger logger = LoggerFactory.getLogger(SSLKsFactory.class);
private final static Logger logger = LogManager.getLogger(SSLKsFactory.class);
private static final SSLKsFactory instance = new SSLKsFactory();

6
engine-api/src/main/java/io/nosqlbench/engine/api/util/SimpleServiceLoader.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.util;
import io.nosqlbench.nb.spi.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
@@ -27,7 +27,7 @@ import java.util.stream.Collectors;
public class SimpleServiceLoader<T extends Named> {
private static final Logger logger = LoggerFactory.getLogger(SimpleServiceLoader.class);
private static final Logger logger = LogManager.getLogger(SimpleServiceLoader.class);
private final Class<? extends T> serviceType;
private static SimpleServiceLoader instance;

26
engine-api/src/main/java/io/nosqlbench/engine/api/util/Unit.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.security.InvalidParameterException;
import java.util.Optional;
@@ -27,14 +27,14 @@ import java.util.regex.Pattern;
public class Unit {
private final static Logger logger = LoggerFactory.getLogger(Unit.class);
private final static Logger logger = LogManager.getLogger(Unit.class);
private static Pattern numberFmtPattern = Pattern.compile(" *(?<number>(?<whole>[0-9]+)(?<fractional>\\.[0-9]+)?(?<to10power>E[0-9]+)?) *(?<unit>[^ ]+?)? *");
private static Pattern numberExponentPattern = Pattern.compile(" *(?<pre>.*?)?(?<number>([0-9]+)(\\.[0-9]+)?+)\\^(?<exponent>[0-9]+)(?<post>.*?)?");
private static final Pattern numberFmtPattern = Pattern.compile(" *(?<number>(?<whole>[0-9]+)(?<fractional>\\.[0-9]+)?(?<to10power>E[0-9]+)?) *(?<unit>[^ ]+?)? *");
private static final Pattern numberExponentPattern = Pattern.compile(" *(?<pre>.*?)?(?<number>([0-9]+)(\\.[0-9]+)?+)\\^(?<exponent>[0-9]+)(?<post>.*?)?");
private static long nanoPerSecond = 1000000000;
private static long bytesPerGB = 1000000000;
private static long BytesPerGiB = 1024 * 1024 * 1024;
private static final long nanoPerSecond = 1000000000;
private static final long bytesPerGB = 1000000000;
private static final long BytesPerGiB = 1024 * 1024 * 1024;
public static Optional<Long> msFor(String duration) {
return durationFor(Duration.MS, duration);
@@ -90,7 +90,7 @@ public class Unit {
double base= Double.valueOf(e.group("number"));
double exponent = Double.valueOf(e.group("exponent"));
double value= Math.pow(base, exponent);
spec = e.group("pre")+ String.valueOf(value) + e.group("post");
spec = e.group("pre")+ value + e.group("post");
}
Matcher m = numberFmtPattern.matcher(spec);
if (m.matches()) {
@@ -181,7 +181,7 @@ public class Unit {
throw new InvalidParameterException("Exponent for powers of two must be 63 or less. It is " + exponent);
}
long value = 1L << exponent;
spec= exponentMatcher.group("pre") + String.valueOf(value) + exponentMatcher.group("post");
spec= exponentMatcher.group("pre") + value + exponentMatcher.group("post");
} else {
spec= exponentMatcher.group("pre") + (long) Math.pow(number, exponent) + exponentMatcher.group("post");
}
@@ -217,7 +217,7 @@ public class Unit {
}
public static enum Count {
public enum Count {
UNIT("U", "unit", 1.0),
KILO("K", "kilo", 1000.0),
MEGA("M", "mega", 1000000.0),
@@ -257,7 +257,7 @@ public class Unit {
}
}
public static enum Bytes {
public enum Bytes {
BYTE("B", "byte", 1),
KB("KB", "kilobyte", 1000),
MB("MB", "megabyte", 1000000),
@@ -310,7 +310,7 @@ public class Unit {
}
}
public static enum Duration {
public enum Duration {
SECOND("s", "seconds", nanoPerSecond),
MS("ms", "milliseconds", 1000000),
US("µs", "microseconds", 1000),

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/rawyaml/BindingEscapingTest.java
View File

@@ -19,15 +19,15 @@ package io.nosqlbench.engine.api.activityconfig.rawyaml;
import io.nosqlbench.virtdata.core.bindings.DataMapper;
import io.nosqlbench.virtdata.core.bindings.VirtData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class BindingEscapingTest {
private final static Logger logger = LoggerFactory.getLogger(BindingEscapingTest.class);
private final static Logger logger = LogManager.getLogger(BindingEscapingTest.class);
@Test
public void testThatEscapesAreNotUnescapedInSingleQuotes() {

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/rawyaml/RawYamlStatementLoaderTest.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityconfig.rawyaml;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import java.util.List;
@@ -27,7 +27,7 @@ import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
public class RawYamlStatementLoaderTest {
private final static Logger logger = LoggerFactory.getLogger(RawYamlStatementLoaderTest.class);
private final static Logger logger = LogManager.getLogger(RawYamlStatementLoaderTest.class);
@Test
public void testLoadPropertiesBlock() {

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/rawyaml/StmtDefTest.java
View File

@@ -23,8 +23,8 @@ import io.nosqlbench.engine.api.activityconfig.yaml.StmtsBlock;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDoc;
import io.nosqlbench.engine.api.activityconfig.yaml.StmtsDocList;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import java.util.List;
import java.util.Map;
@@ -33,7 +33,7 @@ import static org.assertj.core.api.Assertions.assertThat;
public class StmtDefTest {
private final static Logger logger = LoggerFactory.getLogger(StmtDefTest.class);
private final static Logger logger = LogManager.getLogger(StmtDefTest.class);
@Test
public void testLayering() {

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/rawyaml/StmtEscapingTest.java
View File

@@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityconfig.rawyaml;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.yaml.*;
import org.junit.BeforeClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import java.util.List;
@@ -30,7 +30,7 @@ import static org.assertj.core.api.Assertions.assertThat;
public class StmtEscapingTest {
private final static Logger logger = LoggerFactory.getLogger(StmtEscapingTest.class);
private final static Logger logger = LogManager.getLogger(StmtEscapingTest.class);
private static List<OpTemplate> defs;
@BeforeClass

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/rawyaml/StmtVariationTests.java
View File

@@ -17,8 +17,8 @@
package io.nosqlbench.engine.api.activityconfig.rawyaml;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import java.util.List;
@@ -27,7 +27,7 @@ import static org.assertj.core.api.Assertions.assertThat;
public class StmtVariationTests {
private final static Logger logger = LoggerFactory.getLogger(StmtVariationTests.class);
private final static Logger logger = LogManager.getLogger(StmtVariationTests.class);
@Test
public void testListStmtsOnly() {

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/yaml/ParsedStmtTest.java
View File

@@ -20,14 +20,14 @@ package io.nosqlbench.engine.api.activityconfig.yaml;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import io.nosqlbench.engine.api.activityconfig.ParsedStmt;
import org.junit.BeforeClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class ParsedStmtTest {
private static final Logger logger = LoggerFactory.getLogger(ParsedStmtTest.class);
private static final Logger logger = LogManager.getLogger(ParsedStmtTest.class);
private static StmtsDocList doclist;
@BeforeClass

6
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/yaml/StmtDetailOverrideTest.java
View File

@@ -18,8 +18,8 @@
package io.nosqlbench.engine.api.activityconfig.yaml;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import java.util.List;
@@ -27,7 +27,7 @@ import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class StmtDetailOverrideTest {
private static final Logger logger = LoggerFactory.getLogger(StmtDetailOverrideTest.class);
private static final Logger logger = LogManager.getLogger(StmtDetailOverrideTest.class);
@Test
public void testStmtOverrides() {

12
engine-api/src/test/java/io/nosqlbench/engine/api/activityconfig/yaml/StmtsDocListTest.java
View File

@@ -20,8 +20,8 @@ package io.nosqlbench.engine.api.activityconfig.yaml;
import io.nosqlbench.engine.api.activityconfig.StatementsLoader;
import org.assertj.core.data.MapEntry;
import org.junit.BeforeClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
import org.junit.Test;
import java.util.LinkedHashMap;
@@ -32,19 +32,19 @@ import static org.assertj.core.api.Assertions.assertThat;
public class StmtsDocListTest {
private static final Logger logger = LoggerFactory.getLogger(StmtsDocListTest.class);
private static final Logger logger = LogManager.getLogger(StmtsDocListTest.class);
private static StmtsDocList doclist;
private LinkedHashMap<String, String> doc0bindings = new LinkedHashMap<String, String>() {{
private final LinkedHashMap<String, String> doc0bindings = new LinkedHashMap<String, String>() {{
put("b2", "b2d");
put("b1", "b1d");
}};
private LinkedHashMap<String, String> doc0params = new LinkedHashMap<String,String>() {{
private final LinkedHashMap<String, String> doc0params = new LinkedHashMap<String,String>() {{
put("param1","value1");
}};
private LinkedHashMap<String, String> doc0tags = new LinkedHashMap<String,String>() {{
private final LinkedHashMap<String, String> doc0tags = new LinkedHashMap<String,String>() {{
put("atagname","atagvalue");
}};