From 0dcbf80583f3805d4e7a3e28c891a4837debd224 Mon Sep 17 00:00:00 2001 From: Viraj Jasani Date: Wed, 1 Apr 2020 18:22:22 +0530 Subject: [PATCH] HBASE-23937 : Support Online LargeLogs similar to SlowLogs APIs (#1346) Signed-off-by: Bharath Vissapragada --- .../org/apache/hadoop/hbase/client/Admin.java | 10 +- .../hbase/client/AdminOverAsyncAdmin.java | 6 +- .../hadoop/hbase/client/AsyncAdmin.java | 6 +- .../hadoop/hbase/client/AsyncHBaseAdmin.java | 6 +- ...ogQueryFilter.java => LogQueryFilter.java} | 25 +- ...lowLogRecord.java => OnlineLogRecord.java} | 45 ++-- .../hbase/client/RawAsyncHBaseAdmin.java | 47 ++-- .../hbase/shaded/protobuf/ProtobufUtil.java | 18 +- .../shaded/protobuf/RequestConverter.java | 18 +- .../src/main/protobuf/Admin.proto | 3 + .../src/main/protobuf/TooSlowLog.proto | 11 + .../apache/hadoop/hbase/ipc/RpcServer.java | 5 +- .../hbase/regionserver/RSRpcServices.java | 16 ++ ...EventHandler.java => LogEventHandler.java} | 67 +++++- .../regionserver/slowlog/RpcLogDetails.java | 24 +- .../regionserver/slowlog/SlowLogRecorder.java | 35 ++- .../hadoop/hbase/client/TestAdmin2.java | 8 +- .../hadoop/hbase/master/MockRegionServer.java | 6 + .../slowlog/TestSlowLogRecorder.java | 104 ++++++++- .../hbase/rsgroup/VerifyingRSGroupAdmin.java | 8 +- hbase-shell/src/main/ruby/hbase/admin.rb | 28 ++- hbase-shell/src/main/ruby/shell.rb | 1 + .../shell/commands/get_largelog_responses.rb | 78 +++++++ .../thrift2/ThriftHBaseServiceHandler.java | 22 +- .../hadoop/hbase/thrift2/ThriftUtilities.java | 136 +++++++---- .../hbase/thrift2/client/ThriftAdmin.java | 23 +- .../hbase/thrift2/generated/TAppend.java | 2 +- .../thrift2/generated/TAuthorization.java | 2 +- .../thrift2/generated/TBloomFilterType.java | 2 +- .../thrift2/generated/TCellVisibility.java | 2 +- .../hbase/thrift2/generated/TColumn.java | 2 +- .../generated/TColumnFamilyDescriptor.java | 2 +- .../thrift2/generated/TColumnIncrement.java | 2 +- .../hbase/thrift2/generated/TColumnValue.java | 2 +- .../thrift2/generated/TCompareOperator.java | 2 +- .../generated/TCompressionAlgorithm.java | 2 +- .../hbase/thrift2/generated/TConsistency.java | 2 +- .../thrift2/generated/TDataBlockEncoding.java | 2 +- .../hbase/thrift2/generated/TDelete.java | 2 +- .../hbase/thrift2/generated/TDeleteType.java | 2 +- .../hbase/thrift2/generated/TDurability.java | 2 +- .../hadoop/hbase/thrift2/generated/TGet.java | 2 +- .../thrift2/generated/THBaseService.java | 216 +++++++++--------- .../hbase/thrift2/generated/THRegionInfo.java | 2 +- .../thrift2/generated/THRegionLocation.java | 2 +- .../hbase/thrift2/generated/TIOError.java | 2 +- .../thrift2/generated/TIllegalArgument.java | 2 +- .../hbase/thrift2/generated/TIncrement.java | 2 +- .../thrift2/generated/TKeepDeletedCells.java | 2 +- ...gQueryFilter.java => TLogQueryFilter.java} | 200 +++++++++++++--- .../hbase/thrift2/generated/TLogType.java | 43 ++++ .../hbase/thrift2/generated/TMutation.java | 2 +- .../generated/TNamespaceDescriptor.java | 2 +- ...owLogRecord.java => TOnlineLogRecord.java} | 86 +++---- .../hadoop/hbase/thrift2/generated/TPut.java | 2 +- .../hbase/thrift2/generated/TReadType.java | 2 +- .../hbase/thrift2/generated/TResult.java | 2 +- .../thrift2/generated/TRowMutations.java | 2 +- .../hadoop/hbase/thrift2/generated/TScan.java | 2 +- .../hbase/thrift2/generated/TServerName.java | 2 +- .../thrift2/generated/TTableDescriptor.java | 2 +- .../hbase/thrift2/generated/TTableName.java | 2 +- .../thrift2/generated/TThriftServerType.java | 2 +- .../hbase/thrift2/generated/TTimeRange.java | 2 +- .../apache/hadoop/hbase/thrift2/hbase.thrift | 22 +- .../TestThriftHBaseServiceHandler.java | 14 +- 66 files changed, 991 insertions(+), 414 deletions(-) rename hbase-client/src/main/java/org/apache/hadoop/hbase/client/{SlowLogQueryFilter.java => LogQueryFilter.java} (86%) rename hbase-client/src/main/java/org/apache/hadoop/hbase/client/{SlowLogRecord.java => OnlineLogRecord.java} (83%) rename hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/{SlowLogEventHandler.java => LogEventHandler.java} (75%) create mode 100644 hbase-shell/src/main/ruby/shell/commands/get_largelog_responses.rb rename hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/{TSlowLogQueryFilter.java => TLogQueryFilter.java} (79%) create mode 100644 hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogType.java rename hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/{TSlowLogRecord.java => TOnlineLogRecord.java} (94%) diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java index f9b6d7b826e..813e8108e42 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java @@ -2273,19 +2273,19 @@ public interface Admin extends Abortable, Closeable { boolean isSnapshotCleanupEnabled() throws IOException; /** - * Retrieves online slow RPC logs from the provided list of + * Retrieves online slow/large RPC logs from the provided list of * RegionServers * * @param serverNames Server names to get slowlog responses from - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided (determines slow / large RPC logs) * @return online slowlog response list * @throws IOException if a remote or network exception occurs */ - List getSlowLogResponses(final Set serverNames, - final SlowLogQueryFilter slowLogQueryFilter) throws IOException; + List getSlowLogResponses(final Set serverNames, + final LogQueryFilter logQueryFilter) throws IOException; /** - * Clears online slow RPC logs from the provided list of + * Clears online slow/large RPC logs from the provided list of * RegionServers * * @param serverNames Set of Server names to clean slowlog responses from diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AdminOverAsyncAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AdminOverAsyncAdmin.java index 81f6ccc9c5d..e3c888c10a5 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AdminOverAsyncAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AdminOverAsyncAdmin.java @@ -965,9 +965,9 @@ class AdminOverAsyncAdmin implements Admin { } @Override - public List getSlowLogResponses(final Set serverNames, - final SlowLogQueryFilter slowLogQueryFilter) throws IOException { - return get(admin.getSlowLogResponses(serverNames, slowLogQueryFilter)); + public List getSlowLogResponses(final Set serverNames, + final LogQueryFilter logQueryFilter) throws IOException { + return get(admin.getSlowLogResponses(serverNames, logQueryFilter)); } @Override diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java index 40fb5c3cb12..02d9f3b0019 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java @@ -1515,11 +1515,11 @@ public interface AsyncAdmin { * RegionServers * * @param serverNames Server names to get slowlog responses from - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided * @return Online slowlog response list. The return value wrapped by a {@link CompletableFuture} */ - CompletableFuture> getSlowLogResponses(final Set serverNames, - final SlowLogQueryFilter slowLogQueryFilter); + CompletableFuture> getSlowLogResponses(final Set serverNames, + final LogQueryFilter logQueryFilter); /** * Clears online slow RPC logs from the provided list of diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncHBaseAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncHBaseAdmin.java index 24e3c442c75..c3f0da128a9 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncHBaseAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncHBaseAdmin.java @@ -843,9 +843,9 @@ class AsyncHBaseAdmin implements AsyncAdmin { } @Override - public CompletableFuture> getSlowLogResponses( - final Set serverNames, final SlowLogQueryFilter slowLogQueryFilter) { - return wrap(rawAdmin.getSlowLogResponses(serverNames, slowLogQueryFilter)); + public CompletableFuture> getSlowLogResponses( + final Set serverNames, final LogQueryFilter logQueryFilter) { + return wrap(rawAdmin.getSlowLogResponses(serverNames, logQueryFilter)); } @Override diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogQueryFilter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/LogQueryFilter.java similarity index 86% rename from hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogQueryFilter.java rename to hbase-client/src/main/java/org/apache/hadoop/hbase/client/LogQueryFilter.java index aa56a8afab0..8734f7b48d5 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogQueryFilter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/LogQueryFilter.java @@ -25,16 +25,23 @@ import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.yetus.audience.InterfaceAudience; /** - * SlowLog Query Filter with all filter and limit parameters + * Slow/Large Log Query Filter with all filter and limit parameters + * Used by Admin API: getSlowLogResponses */ @InterfaceAudience.Private -public class SlowLogQueryFilter { +public class LogQueryFilter { private String regionName; private String clientAddress; private String tableName; private String userName; private int limit = 10; + private Type type = Type.SLOW_LOG; + + public enum Type { + SLOW_LOG, + LARGE_LOG + } public String getRegionName() { return regionName; @@ -76,6 +83,14 @@ public class SlowLogQueryFilter { this.limit = limit; } + public Type getType() { + return type; + } + + public void setType(Type type) { + this.type = type; + } + @Override public boolean equals(Object o) { if (this == o) { @@ -86,7 +101,7 @@ public class SlowLogQueryFilter { return false; } - SlowLogQueryFilter that = (SlowLogQueryFilter) o; + LogQueryFilter that = (LogQueryFilter) o; return new EqualsBuilder() .append(limit, that.limit) @@ -94,6 +109,7 @@ public class SlowLogQueryFilter { .append(clientAddress, that.clientAddress) .append(tableName, that.tableName) .append(userName, that.userName) + .append(type, that.type) .isEquals(); } @@ -105,6 +121,7 @@ public class SlowLogQueryFilter { .append(tableName) .append(userName) .append(limit) + .append(type) .toHashCode(); } @@ -116,7 +133,7 @@ public class SlowLogQueryFilter { .append("tableName", tableName) .append("userName", userName) .append("limit", limit) + .append("type", type) .toString(); } - } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogRecord.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/OnlineLogRecord.java similarity index 83% rename from hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogRecord.java rename to hbase-client/src/main/java/org/apache/hadoop/hbase/client/OnlineLogRecord.java index 95936186047..8af001369d6 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/SlowLogRecord.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/OnlineLogRecord.java @@ -30,16 +30,17 @@ import org.apache.hbase.thirdparty.com.google.gson.JsonObject; import org.apache.hbase.thirdparty.com.google.gson.JsonSerializer; /** - * SlowLog payload for hbase-client, to be used by Admin API get_slow_responses + * Slow/Large Log payload for hbase-client, to be used by Admin API get_slow_responses and + * get_large_responses */ @InterfaceAudience.Private -final public class SlowLogRecord { +final public class OnlineLogRecord { // used to convert object to pretty printed format // used by toJsonPrettyPrint() private static final Gson GSON = GsonUtil.createGson() .setPrettyPrinting() - .registerTypeAdapter(SlowLogRecord.class, (JsonSerializer) + .registerTypeAdapter(OnlineLogRecord.class, (JsonSerializer) (slowLogPayload, type, jsonSerializationContext) -> { Gson gson = new Gson(); JsonObject jsonObj = (JsonObject) gson.toJsonTree(slowLogPayload); @@ -128,7 +129,7 @@ final public class SlowLogRecord { return multiServiceCalls; } - private SlowLogRecord(final long startTime, final int processingTime, final int queueTime, + private OnlineLogRecord(final long startTime, final int processingTime, final int queueTime, final long responseSize, final String clientAddress, final String serverClass, final String methodName, final String callDetails, final String param, final String regionName, final String userName, final int multiGetsCount, @@ -149,7 +150,7 @@ final public class SlowLogRecord { this.multiServiceCalls = multiServiceCalls; } - public static class SlowLogRecordBuilder { + public static class OnlineLogRecordBuilder { private long startTime; private int processingTime; private int queueTime; @@ -165,78 +166,78 @@ final public class SlowLogRecord { private int multiMutationsCount; private int multiServiceCalls; - public SlowLogRecordBuilder setStartTime(long startTime) { + public OnlineLogRecordBuilder setStartTime(long startTime) { this.startTime = startTime; return this; } - public SlowLogRecordBuilder setProcessingTime(int processingTime) { + public OnlineLogRecordBuilder setProcessingTime(int processingTime) { this.processingTime = processingTime; return this; } - public SlowLogRecordBuilder setQueueTime(int queueTime) { + public OnlineLogRecordBuilder setQueueTime(int queueTime) { this.queueTime = queueTime; return this; } - public SlowLogRecordBuilder setResponseSize(long responseSize) { + public OnlineLogRecordBuilder setResponseSize(long responseSize) { this.responseSize = responseSize; return this; } - public SlowLogRecordBuilder setClientAddress(String clientAddress) { + public OnlineLogRecordBuilder setClientAddress(String clientAddress) { this.clientAddress = clientAddress; return this; } - public SlowLogRecordBuilder setServerClass(String serverClass) { + public OnlineLogRecordBuilder setServerClass(String serverClass) { this.serverClass = serverClass; return this; } - public SlowLogRecordBuilder setMethodName(String methodName) { + public OnlineLogRecordBuilder setMethodName(String methodName) { this.methodName = methodName; return this; } - public SlowLogRecordBuilder setCallDetails(String callDetails) { + public OnlineLogRecordBuilder setCallDetails(String callDetails) { this.callDetails = callDetails; return this; } - public SlowLogRecordBuilder setParam(String param) { + public OnlineLogRecordBuilder setParam(String param) { this.param = param; return this; } - public SlowLogRecordBuilder setRegionName(String regionName) { + public OnlineLogRecordBuilder setRegionName(String regionName) { this.regionName = regionName; return this; } - public SlowLogRecordBuilder setUserName(String userName) { + public OnlineLogRecordBuilder setUserName(String userName) { this.userName = userName; return this; } - public SlowLogRecordBuilder setMultiGetsCount(int multiGetsCount) { + public OnlineLogRecordBuilder setMultiGetsCount(int multiGetsCount) { this.multiGetsCount = multiGetsCount; return this; } - public SlowLogRecordBuilder setMultiMutationsCount(int multiMutationsCount) { + public OnlineLogRecordBuilder setMultiMutationsCount(int multiMutationsCount) { this.multiMutationsCount = multiMutationsCount; return this; } - public SlowLogRecordBuilder setMultiServiceCalls(int multiServiceCalls) { + public OnlineLogRecordBuilder setMultiServiceCalls(int multiServiceCalls) { this.multiServiceCalls = multiServiceCalls; return this; } - public SlowLogRecord build() { - return new SlowLogRecord(startTime, processingTime, queueTime, responseSize, + public OnlineLogRecord build() { + return new OnlineLogRecord(startTime, processingTime, queueTime, responseSize, clientAddress, serverClass, methodName, callDetails, param, regionName, userName, multiGetsCount, multiMutationsCount, multiServiceCalls); } @@ -252,7 +253,7 @@ final public class SlowLogRecord { return false; } - SlowLogRecord that = (SlowLogRecord) o; + OnlineLogRecord that = (OnlineLogRecord) o; return new EqualsBuilder() .append(startTime, that.startTime) diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncHBaseAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncHBaseAdmin.java index 4c72e1c3b71..6b504ee23cc 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncHBaseAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncHBaseAdmin.java @@ -3951,31 +3951,52 @@ class RawAsyncHBaseAdmin implements AsyncAdmin { } @Override - public CompletableFuture> getSlowLogResponses( - @Nullable final Set serverNames, - final SlowLogQueryFilter slowLogQueryFilter) { + public CompletableFuture> getSlowLogResponses( + @Nullable final Set serverNames, + final LogQueryFilter logQueryFilter) { if (CollectionUtils.isEmpty(serverNames)) { return CompletableFuture.completedFuture(Collections.emptyList()); } - return CompletableFuture.supplyAsync(() -> serverNames.stream() - .map((ServerName serverName) -> - getSlowLogResponseFromServer(serverName, slowLogQueryFilter)) - .map(CompletableFuture::join) - .flatMap(List::stream) - .collect(Collectors.toList())); + if (logQueryFilter.getType() == null + || logQueryFilter.getType() == LogQueryFilter.Type.SLOW_LOG) { + return CompletableFuture.supplyAsync(() -> serverNames.stream() + .map((ServerName serverName) -> + getSlowLogResponseFromServer(serverName, logQueryFilter)) + .map(CompletableFuture::join) + .flatMap(List::stream) + .collect(Collectors.toList())); + } else { + return CompletableFuture.supplyAsync(() -> serverNames.stream() + .map((ServerName serverName) -> + getLargeLogResponseFromServer(serverName, logQueryFilter)) + .map(CompletableFuture::join) + .flatMap(List::stream) + .collect(Collectors.toList())); + } } - private CompletableFuture> getSlowLogResponseFromServer( - final ServerName serverName, final SlowLogQueryFilter slowLogQueryFilter) { - return this.>newAdminCaller() + private CompletableFuture> getSlowLogResponseFromServer( + final ServerName serverName, final LogQueryFilter logQueryFilter) { + return this.>newAdminCaller() .action((controller, stub) -> this .adminCall( - controller, stub, RequestConverter.buildSlowLogResponseRequest(slowLogQueryFilter), + controller, stub, RequestConverter.buildSlowLogResponseRequest(logQueryFilter), AdminService.Interface::getSlowLogResponses, ProtobufUtil::toSlowLogPayloads)) .serverName(serverName).call(); } + private CompletableFuture> getLargeLogResponseFromServer( + final ServerName serverName, final LogQueryFilter logQueryFilter) { + return this.>newAdminCaller() + .action((controller, stub) -> this + .adminCall( + controller, stub, RequestConverter.buildSlowLogResponseRequest(logQueryFilter), + AdminService.Interface::getLargeLogResponses, + ProtobufUtil::toSlowLogPayloads)) + .serverName(serverName).call(); + } + @Override public CompletableFuture> clearSlowLogResponses( @Nullable Set serverNames) { diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java index 7ba7265a8a0..66e4c4105c4 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java @@ -76,6 +76,7 @@ import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; import org.apache.hadoop.hbase.client.Mutation; +import org.apache.hadoop.hbase.client.OnlineLogRecord; import org.apache.hadoop.hbase.client.PackagePrivateFieldAccessor; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.RegionInfoBuilder; @@ -85,7 +86,6 @@ import org.apache.hadoop.hbase.client.RegionStatesCount; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.SlowLogParams; -import org.apache.hadoop.hbase.client.SlowLogRecord; import org.apache.hadoop.hbase.client.SnapshotDescription; import org.apache.hadoop.hbase.client.SnapshotType; import org.apache.hadoop.hbase.client.TableDescriptor; @@ -3522,14 +3522,14 @@ public final class ProtobufUtil { /** * Convert Protobuf class * {@link org.apache.hadoop.hbase.shaded.protobuf.generated.TooSlowLog.SlowLogPayload} - * To client SlowLog Payload class {@link SlowLogRecord} + * To client SlowLog Payload class {@link OnlineLogRecord} * * @param slowLogPayload SlowLog Payload protobuf instance * @return SlowLog Payload for client usecase */ - private static SlowLogRecord getSlowLogRecord( + private static OnlineLogRecord getSlowLogRecord( final TooSlowLog.SlowLogPayload slowLogPayload) { - SlowLogRecord clientSlowLogRecord = new SlowLogRecord.SlowLogRecordBuilder() + OnlineLogRecord onlineLogRecord = new OnlineLogRecord.OnlineLogRecordBuilder() .setCallDetails(slowLogPayload.getCallDetails()) .setClientAddress(slowLogPayload.getClientAddress()) .setMethodName(slowLogPayload.getMethodName()) @@ -3545,20 +3545,20 @@ public final class ProtobufUtil { .setStartTime(slowLogPayload.getStartTime()) .setUserName(slowLogPayload.getUserName()) .build(); - return clientSlowLogRecord; + return onlineLogRecord; } /** - * Convert AdminProtos#SlowLogResponses to list of {@link SlowLogRecord} + * Convert AdminProtos#SlowLogResponses to list of {@link OnlineLogRecord} * * @param slowLogResponses slowlog response protobuf instance * @return list of SlowLog payloads for client usecase */ - public static List toSlowLogPayloads( + public static List toSlowLogPayloads( final AdminProtos.SlowLogResponses slowLogResponses) { - List slowLogRecords = slowLogResponses.getSlowLogPayloadsList() + List onlineLogRecords = slowLogResponses.getSlowLogPayloadsList() .stream().map(ProtobufUtil::getSlowLogRecord).collect(Collectors.toList()); - return slowLogRecords; + return onlineLogRecords; } /** diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java index 2b02cf6d561..9a5156d992f 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java @@ -50,7 +50,7 @@ import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.Row; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; -import org.apache.hadoop.hbase.client.SlowLogQueryFilter; +import org.apache.hadoop.hbase.client.LogQueryFilter; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.TableState; import org.apache.hadoop.hbase.client.replication.ReplicationPeerConfigUtil; @@ -1754,32 +1754,32 @@ public final class RequestConverter { /** * Create a protocol buffer {@link SlowLogResponseRequest} * - * @param slowLogQueryFilter filter to use if provided + * @param logQueryFilter filter to use if provided * @return a protocol buffer SlowLogResponseRequest */ public static SlowLogResponseRequest buildSlowLogResponseRequest( - final SlowLogQueryFilter slowLogQueryFilter) { + final LogQueryFilter logQueryFilter) { SlowLogResponseRequest.Builder builder = SlowLogResponseRequest.newBuilder(); - if (slowLogQueryFilter == null) { + if (logQueryFilter == null) { return builder.build(); } - final String clientAddress = slowLogQueryFilter.getClientAddress(); + final String clientAddress = logQueryFilter.getClientAddress(); if (StringUtils.isNotEmpty(clientAddress)) { builder.setClientAddress(clientAddress); } - final String regionName = slowLogQueryFilter.getRegionName(); + final String regionName = logQueryFilter.getRegionName(); if (StringUtils.isNotEmpty(regionName)) { builder.setRegionName(regionName); } - final String tableName = slowLogQueryFilter.getTableName(); + final String tableName = logQueryFilter.getTableName(); if (StringUtils.isNotEmpty(tableName)) { builder.setTableName(tableName); } - final String userName = slowLogQueryFilter.getUserName(); + final String userName = logQueryFilter.getUserName(); if (StringUtils.isNotEmpty(userName)) { builder.setUserName(userName); } - return builder.setLimit(slowLogQueryFilter.getLimit()).build(); + return builder.setLimit(logQueryFilter.getLimit()).build(); } /** diff --git a/hbase-protocol-shaded/src/main/protobuf/Admin.proto b/hbase-protocol-shaded/src/main/protobuf/Admin.proto index 34c9806c554..8dd55162783 100644 --- a/hbase-protocol-shaded/src/main/protobuf/Admin.proto +++ b/hbase-protocol-shaded/src/main/protobuf/Admin.proto @@ -369,6 +369,9 @@ service AdminService { rpc GetSlowLogResponses(SlowLogResponseRequest) returns(SlowLogResponses); + rpc GetLargeLogResponses(SlowLogResponseRequest) + returns(SlowLogResponses); + rpc ClearSlowLogsResponses(ClearSlowLogResponseRequest) returns(ClearSlowLogResponses); } diff --git a/hbase-protocol-shaded/src/main/protobuf/TooSlowLog.proto b/hbase-protocol-shaded/src/main/protobuf/TooSlowLog.proto index 26dabde901c..36ed9d504a7 100644 --- a/hbase-protocol-shaded/src/main/protobuf/TooSlowLog.proto +++ b/hbase-protocol-shaded/src/main/protobuf/TooSlowLog.proto @@ -42,4 +42,15 @@ message SlowLogPayload { optional int32 multi_gets = 12 [default = 0]; optional int32 multi_mutations = 13 [default = 0]; optional int32 multi_service_calls = 14 [default = 0]; + required Type type = 15; + + // SLOW_LOG is RPC call slow in nature whereas LARGE_LOG is RPC call quite large. + // Majority of times, slow logs are also large logs and hence, ALL is combination of + // both + enum Type { + SLOW_LOG = 0; + LARGE_LOG = 1; + ALL = 2; + } + } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/ipc/RpcServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/ipc/RpcServer.java index 44909b272f4..ce7a583e297 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/ipc/RpcServer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/ipc/RpcServer.java @@ -427,12 +427,13 @@ public abstract class RpcServer implements RpcServerInterface, tooLarge, tooSlow, status.getClient(), startTime, processingTime, qTime, responseSize, userName); - if (tooSlow && this.slowLogRecorder != null) { + if (this.slowLogRecorder != null) { // send logs to ring buffer owned by slowLogRecorder final String className = server == null ? StringUtils.EMPTY : server.getClass().getSimpleName(); this.slowLogRecorder.addSlowLogPayload( - new RpcLogDetails(call, status.getClient(), responseSize, className)); + new RpcLogDetails(call, status.getClient(), responseSize, className, tooSlow, + tooLarge)); } } return new Pair<>(result, controller.cellScanner()); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java index fe6b04bc361..d7381d1bbb9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java @@ -3872,6 +3872,22 @@ public class RSRpcServices implements HBaseRPCErrorHandler, return slowLogResponses; } + @Override + @QosPriority(priority = HConstants.ADMIN_QOS) + public SlowLogResponses getLargeLogResponses(final RpcController controller, + final SlowLogResponseRequest request) { + final SlowLogRecorder slowLogRecorder = + this.regionServer.getSlowLogRecorder(); + final List slowLogPayloads; + slowLogPayloads = slowLogRecorder != null + ? slowLogRecorder.getLargeLogPayloads(request) + : Collections.emptyList(); + SlowLogResponses slowLogResponses = SlowLogResponses.newBuilder() + .addAllSlowLogPayloads(slowLogPayloads) + .build(); + return slowLogResponses; + } + @Override @QosPriority(priority = HConstants.ADMIN_QOS) public ClearSlowLogResponses clearSlowLogsResponses(final RpcController controller, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogEventHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/LogEventHandler.java similarity index 75% rename from hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogEventHandler.java rename to hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/LogEventHandler.java index 24e8460e2b4..508f08697ec 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogEventHandler.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/LogEventHandler.java @@ -50,13 +50,13 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.TooSlowLog.SlowLogPaylo * Event Handler run by disruptor ringbuffer consumer */ @InterfaceAudience.Private -class SlowLogEventHandler implements EventHandler { +class LogEventHandler implements EventHandler { - private static final Logger LOG = LoggerFactory.getLogger(SlowLogEventHandler.class); + private static final Logger LOG = LoggerFactory.getLogger(LogEventHandler.class); private final Queue queue; - SlowLogEventHandler(int eventCount) { + LogEventHandler(int eventCount) { EvictingQueue evictingQueue = EvictingQueue.create(eventCount); queue = Queues.synchronizedQueue(evictingQueue); } @@ -78,6 +78,10 @@ class SlowLogEventHandler implements EventHandler { final String clientAddress = rpcCallDetails.getClientAddress(); final long responseSize = rpcCallDetails.getResponseSize(); final String className = rpcCallDetails.getClassName(); + final SlowLogPayload.Type type = getLogType(rpcCallDetails); + if (type == null) { + return; + } Descriptors.MethodDescriptor methodDescriptor = rpcCall.getMethod(); Message param = rpcCall.getParam(); long receiveTime = rpcCall.getReceiveTime(); @@ -122,11 +126,31 @@ class SlowLogEventHandler implements EventHandler { .setResponseSize(responseSize) .setServerClass(className) .setStartTime(startTime) + .setType(type) .setUserName(userName) .build(); queue.add(slowLogPayload); } + private SlowLogPayload.Type getLogType(RpcLogDetails rpcCallDetails) { + final boolean isSlowLog = rpcCallDetails.isSlowLog(); + final boolean isLargeLog = rpcCallDetails.isLargeLog(); + final SlowLogPayload.Type type; + if (!isSlowLog && !isLargeLog) { + LOG.error("slowLog and largeLog both are false. Ignoring the event. rpcCallDetails: {}", + rpcCallDetails); + return null; + } + if (isSlowLog && isLargeLog) { + type = SlowLogPayload.Type.ALL; + } else if (isSlowLog) { + type = SlowLogPayload.Type.SLOW_LOG; + } else { + type = SlowLogPayload.Type.LARGE_LOG; + } + return type; + } + /** * Cleans up slow log payloads * @@ -148,17 +172,44 @@ class SlowLogEventHandler implements EventHandler { */ List getSlowLogPayloads(final AdminProtos.SlowLogResponseRequest request) { List slowLogPayloadList = - Arrays.stream(queue.toArray(new SlowLogPayload[0])).collect(Collectors.toList()); + Arrays.stream(queue.toArray(new SlowLogPayload[0])) + .filter(e -> e.getType() == SlowLogPayload.Type.ALL + || e.getType() == SlowLogPayload.Type.SLOW_LOG) + .collect(Collectors.toList()); // latest slow logs first, operator is interested in latest records from in-memory buffer Collections.reverse(slowLogPayloadList); + return getFilteredLogs(request, slowLogPayloadList); + } + + /** + * Retrieve list of large log payloads + * + * @param request large log request parameters + * @return list of large log payloads + */ + List getLargeLogPayloads(final AdminProtos.SlowLogResponseRequest request) { + List slowLogPayloadList = + Arrays.stream(queue.toArray(new SlowLogPayload[0])) + .filter(e -> e.getType() == SlowLogPayload.Type.ALL + || e.getType() == SlowLogPayload.Type.LARGE_LOG) + .collect(Collectors.toList()); + + // latest large logs first, operator is interested in latest records from in-memory buffer + Collections.reverse(slowLogPayloadList); + + return getFilteredLogs(request, slowLogPayloadList); + } + + private List getFilteredLogs(AdminProtos.SlowLogResponseRequest request, + List logPayloadList) { if (isFilterProvided(request)) { - slowLogPayloadList = filterSlowLogs(request, slowLogPayloadList); + logPayloadList = filterLogs(request, logPayloadList); } - int limit = request.getLimit() >= slowLogPayloadList.size() ? slowLogPayloadList.size() + int limit = request.getLimit() >= logPayloadList.size() ? logPayloadList.size() : request.getLimit(); - return slowLogPayloadList.subList(0, limit); + return logPayloadList.subList(0, limit); } private boolean isFilterProvided(AdminProtos.SlowLogResponseRequest request) { @@ -174,7 +225,7 @@ class SlowLogEventHandler implements EventHandler { return StringUtils.isNotEmpty(request.getRegionName()); } - private List filterSlowLogs(AdminProtos.SlowLogResponseRequest request, + private List filterLogs(AdminProtos.SlowLogResponseRequest request, List slowLogPayloadList) { List filteredSlowLogPayloads = new ArrayList<>(); for (SlowLogPayload slowLogPayload : slowLogPayloadList) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/RpcLogDetails.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/RpcLogDetails.java index e7ab7d499b3..7d5558cde73 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/RpcLogDetails.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/RpcLogDetails.java @@ -29,17 +29,21 @@ import org.apache.yetus.audience.InterfaceAudience; @InterfaceAudience.Private public class RpcLogDetails { - private RpcCall rpcCall; - private String clientAddress; - private long responseSize; - private String className; + private final RpcCall rpcCall; + private final String clientAddress; + private final long responseSize; + private final String className; + private final boolean isSlowLog; + private final boolean isLargeLog; public RpcLogDetails(RpcCall rpcCall, String clientAddress, long responseSize, - String className) { + String className, boolean isSlowLog, boolean isLargeLog) { this.rpcCall = rpcCall; this.clientAddress = clientAddress; this.responseSize = responseSize; this.className = className; + this.isSlowLog = isSlowLog; + this.isLargeLog = isLargeLog; } public RpcCall getRpcCall() { @@ -58,6 +62,14 @@ public class RpcLogDetails { return className; } + public boolean isSlowLog() { + return isSlowLog; + } + + public boolean isLargeLog() { + return isLargeLog; + } + @Override public String toString() { return new ToStringBuilder(this) @@ -65,6 +77,8 @@ public class RpcLogDetails { .append("clientAddress", clientAddress) .append("responseSize", responseSize) .append("className", className) + .append("isSlowLog", isSlowLog) + .append("isLargeLog", isLargeLog) .toString(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogRecorder.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogRecorder.java index d750642d4a1..a69b0adb5df 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogRecorder.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/slowlog/SlowLogRecorder.java @@ -39,7 +39,7 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.TooSlowLog.SlowLogPayload; /** - * Online SlowLog Provider Service that keeps slow RPC logs in the ring buffer. + * Online Slow/Large Log Provider Service that keeps slow/large RPC logs in the ring buffer. * The service uses LMAX Disruptor to save slow records which are then consumed by * a queue and based on the ring buffer size, the available records are then fetched * from the queue in thread-safe manner. @@ -49,9 +49,9 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.TooSlowLog.SlowLogPaylo public class SlowLogRecorder { private final Disruptor disruptor; - private final SlowLogEventHandler slowLogEventHandler; + private final LogEventHandler logEventHandler; private final int eventCount; - private final boolean isOnlineSlowLogProviderEnabled; + private final boolean isOnlineLogProviderEnabled; private static final String SLOW_LOG_RING_BUFFER_SIZE = "hbase.regionserver.slowlog.ringbuffer.size"; @@ -60,12 +60,12 @@ public class SlowLogRecorder { * Initialize disruptor with configurable ringbuffer size */ public SlowLogRecorder(Configuration conf) { - isOnlineSlowLogProviderEnabled = conf.getBoolean(HConstants.SLOW_LOG_BUFFER_ENABLED_KEY, + isOnlineLogProviderEnabled = conf.getBoolean(HConstants.SLOW_LOG_BUFFER_ENABLED_KEY, HConstants.DEFAULT_ONLINE_LOG_PROVIDER_ENABLED); - if (!isOnlineSlowLogProviderEnabled) { + if (!isOnlineLogProviderEnabled) { this.disruptor = null; - this.slowLogEventHandler = null; + this.logEventHandler = null; this.eventCount = 0; return; } @@ -86,8 +86,8 @@ public class SlowLogRecorder { this.disruptor.setDefaultExceptionHandler(new DisruptorExceptionHandler()); // initialize ringbuffer event handler - this.slowLogEventHandler = new SlowLogEventHandler(this.eventCount); - this.disruptor.handleEventsWith(new SlowLogEventHandler[]{this.slowLogEventHandler}); + this.logEventHandler = new LogEventHandler(this.eventCount); + this.disruptor.handleEventsWith(new LogEventHandler[]{this.logEventHandler}); this.disruptor.start(); } @@ -113,7 +113,18 @@ public class SlowLogRecorder { * @return online slow logs from ringbuffer */ public List getSlowLogPayloads(AdminProtos.SlowLogResponseRequest request) { - return isOnlineSlowLogProviderEnabled ? this.slowLogEventHandler.getSlowLogPayloads(request) + return isOnlineLogProviderEnabled ? this.logEventHandler.getSlowLogPayloads(request) + : Collections.emptyList(); + } + + /** + * Retrieve online large logs from ringbuffer + * + * @param request large log request parameters + * @return online large logs from ringbuffer + */ + public List getLargeLogPayloads(AdminProtos.SlowLogResponseRequest request) { + return isOnlineLogProviderEnabled ? this.logEventHandler.getLargeLogPayloads(request) : Collections.emptyList(); } @@ -125,10 +136,10 @@ public class SlowLogRecorder { * clean up slow logs */ public boolean clearSlowLogPayloads() { - if (!isOnlineSlowLogProviderEnabled) { + if (!isOnlineLogProviderEnabled) { return true; } - return this.slowLogEventHandler.clearSlowLogs(); + return this.logEventHandler.clearSlowLogs(); } /** @@ -138,7 +149,7 @@ public class SlowLogRecorder { * consumers */ public void addSlowLogPayload(RpcLogDetails rpcLogDetails) { - if (!isOnlineSlowLogProviderEnabled) { + if (!isOnlineLogProviderEnabled) { return; } RingBuffer ringBuffer = this.disruptor.getRingBuffer(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java index 558af189148..9c379277552 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java @@ -856,12 +856,12 @@ public class TestAdmin2 extends TestAdminBase { } Assert.assertEquals(countFailedClearSlowResponse, 0); - SlowLogQueryFilter slowLogQueryFilter = new SlowLogQueryFilter(); - List slowLogRecords = ADMIN.getSlowLogResponses(new HashSet<>(serverNames), - slowLogQueryFilter); + LogQueryFilter logQueryFilter = new LogQueryFilter(); + List onlineLogRecords = ADMIN.getSlowLogResponses(new HashSet<>(serverNames), + logQueryFilter); // after cleanup of slowlog responses, total count of slowlog payloads should be 0 - Assert.assertEquals(slowLogRecords.size(), 0); + Assert.assertEquals(onlineLogRecords.size(), 0); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java index 3159088c82c..1b2d86e19aa 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java @@ -684,6 +684,12 @@ class MockRegionServer implements AdminProtos.AdminService.BlockingInterface, return null; } + @Override + public SlowLogResponses getLargeLogResponses(RpcController controller, + SlowLogResponseRequest request) throws ServiceException { + return null; + } + @Override public ClearSlowLogResponses clearSlowLogsResponses(RpcController controller, ClearSlowLogResponseRequest request) throws ServiceException { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/slowlog/TestSlowLogRecorder.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/slowlog/TestSlowLogRecorder.java index 72afdd4f1f5..bdd5c89be0b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/slowlog/TestSlowLogRecorder.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/slowlog/TestSlowLogRecorder.java @@ -195,6 +195,19 @@ public class TestSlowLogRecorder { }) ); + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, + () -> { + List slowLogPayloadsList = slowLogRecorder.getLargeLogPayloads(request); + // confirm ringbuffer is full + // and ordered events + return slowLogPayloadsList.size() == 8 + && confirmPayloadParams(0, 14, slowLogPayloadsList) + && confirmPayloadParams(1, 13, slowLogPayloadsList) + && confirmPayloadParams(2, 12, slowLogPayloadsList) + && confirmPayloadParams(3, 11, slowLogPayloadsList); + }) + ); + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, () -> { boolean isRingBufferCleaned = slowLogRecorder.clearSlowLogPayloads(); @@ -388,11 +401,100 @@ public class TestSlowLogRecorder { Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor( 5000, () -> slowLogRecorder.getSlowLogPayloads(request).size() > 10000)); + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor( + 5000, () -> slowLogRecorder.getLargeLogPayloads(request).size() > 10000)); + } + + @Test + public void testSlowLargeLogEvents() throws Exception { + Configuration conf = applySlowLogRecorderConf(28); + slowLogRecorder = new SlowLogRecorder(conf); + AdminProtos.SlowLogResponseRequest request = + AdminProtos.SlowLogResponseRequest.newBuilder().setLimit(14 * 11).build(); + + Assert.assertEquals(slowLogRecorder.getSlowLogPayloads(request).size(), 0); + LOG.debug("Initially ringbuffer of Slow Log records is empty"); + + boolean isSlowLog; + boolean isLargeLog; + for (int i = 0; i < 14 * 11; i++) { + if (i % 2 == 0) { + isSlowLog = true; + isLargeLog = false; + } else { + isSlowLog = false; + isLargeLog = true; + } + RpcLogDetails rpcLogDetails = + getRpcLogDetails("userName_" + (i + 1), "client_" + (i + 1), "class_" + (i + 1), + isSlowLog, isLargeLog); + slowLogRecorder.addSlowLogPayload(rpcLogDetails); + } + LOG.debug("Added 14 * 11 records, ringbuffer should only provide latest 14 records"); + + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, + () -> slowLogRecorder.getSlowLogPayloads(request).size() == 14)); + + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, + () -> { + List slowLogPayloads = slowLogRecorder.getSlowLogPayloads(request); + + // confirm strict order of slow log payloads + return slowLogPayloads.size() == 14 + && confirmPayloadParams(0, 153, slowLogPayloads) + && confirmPayloadParams(1, 151, slowLogPayloads) + && confirmPayloadParams(2, 149, slowLogPayloads) + && confirmPayloadParams(3, 147, slowLogPayloads) + && confirmPayloadParams(4, 145, slowLogPayloads) + && confirmPayloadParams(5, 143, slowLogPayloads) + && confirmPayloadParams(6, 141, slowLogPayloads) + && confirmPayloadParams(7, 139, slowLogPayloads) + && confirmPayloadParams(8, 137, slowLogPayloads) + && confirmPayloadParams(9, 135, slowLogPayloads) + && confirmPayloadParams(10, 133, slowLogPayloads) + && confirmPayloadParams(11, 131, slowLogPayloads) + && confirmPayloadParams(12, 129, slowLogPayloads) + && confirmPayloadParams(13, 127, slowLogPayloads); + }) + ); + + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, + () -> slowLogRecorder.getLargeLogPayloads(request).size() == 14)); + + Assert.assertNotEquals(-1, HBASE_TESTING_UTILITY.waitFor(3000, + () -> { + List largeLogPayloads = slowLogRecorder.getLargeLogPayloads(request); + + // confirm strict order of slow log payloads + return largeLogPayloads.size() == 14 + && confirmPayloadParams(0, 154, largeLogPayloads) + && confirmPayloadParams(1, 152, largeLogPayloads) + && confirmPayloadParams(2, 150, largeLogPayloads) + && confirmPayloadParams(3, 148, largeLogPayloads) + && confirmPayloadParams(4, 146, largeLogPayloads) + && confirmPayloadParams(5, 144, largeLogPayloads) + && confirmPayloadParams(6, 142, largeLogPayloads) + && confirmPayloadParams(7, 140, largeLogPayloads) + && confirmPayloadParams(8, 138, largeLogPayloads) + && confirmPayloadParams(9, 136, largeLogPayloads) + && confirmPayloadParams(10, 134, largeLogPayloads) + && confirmPayloadParams(11, 132, largeLogPayloads) + && confirmPayloadParams(12, 130, largeLogPayloads) + && confirmPayloadParams(13, 128, largeLogPayloads); + }) + ); + } private RpcLogDetails getRpcLogDetails(String userName, String clientAddress, String className) { - return new RpcLogDetails(getRpcCall(userName), clientAddress, 0, className); + return new RpcLogDetails(getRpcCall(userName), clientAddress, 0, className, true, true); + } + + private RpcLogDetails getRpcLogDetails(String userName, String clientAddress, + String className, boolean isSlowLog, boolean isLargeLog) { + return new RpcLogDetails(getRpcCall(userName), clientAddress, 0, className, isSlowLog, + isLargeLog); } private RpcCall getRpcCall(String userName) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/VerifyingRSGroupAdmin.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/VerifyingRSGroupAdmin.java index 12d61109613..8ff50f1e5fb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/VerifyingRSGroupAdmin.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/rsgroup/VerifyingRSGroupAdmin.java @@ -48,12 +48,12 @@ import org.apache.hadoop.hbase.client.CompactType; import org.apache.hadoop.hbase.client.CompactionState; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; +import org.apache.hadoop.hbase.client.OnlineLogRecord; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; -import org.apache.hadoop.hbase.client.SlowLogQueryFilter; -import org.apache.hadoop.hbase.client.SlowLogRecord; +import org.apache.hadoop.hbase.client.LogQueryFilter; import org.apache.hadoop.hbase.client.SnapshotDescription; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.TableDescriptor; @@ -886,8 +886,8 @@ public class VerifyingRSGroupAdmin implements Admin, Closeable { } @Override - public List getSlowLogResponses(Set serverNames, - SlowLogQueryFilter slowLogQueryFilter) throws IOException { + public List getSlowLogResponses(Set serverNames, + LogQueryFilter logQueryFilter) throws IOException { return null; } diff --git a/hbase-shell/src/main/ruby/hbase/admin.rb b/hbase-shell/src/main/ruby/hbase/admin.rb index 0d6dbfc6e43..226a480ee84 100644 --- a/hbase-shell/src/main/ruby/hbase/admin.rb +++ b/hbase-shell/src/main/ruby/hbase/admin.rb @@ -1482,6 +1482,7 @@ module Hbase server_names = getServerNames(server_names_list, false) end filter_params = get_filter_params(args) + filter_params.setType(org.apache.hadoop.hbase.client.LogQueryFilter::Type::SLOW_LOG) slow_log_responses = @admin.getSlowLogResponses(java.util.HashSet.new(server_names), filter_params) slow_log_responses_arr = [] @@ -1493,7 +1494,7 @@ module Hbase end def get_filter_params(args) - filter_params = org.apache.hadoop.hbase.client.SlowLogQueryFilter.new + filter_params = org.apache.hadoop.hbase.client.LogQueryFilter.new if args.key? 'REGION_NAME' region_name = args['REGION_NAME'] filter_params.setRegionName(region_name) @@ -1517,6 +1518,31 @@ module Hbase filter_params end + #---------------------------------------------------------------------------------------------- + # Retrieve LargeLog Responses from RegionServers + def get_largelog_responses(server_names, args) + unless server_names.is_a?(Array) || server_names.is_a?(String) + raise(ArgumentError, + "#{server_names.class} of #{server_names.inspect} is not of Array/String type") + end + if server_names == '*' + server_names = getServerNames([], true) + else + server_names_list = to_server_names(server_names) + server_names = getServerNames(server_names_list, false) + end + filter_params = get_filter_params(args) + filter_params.setType(org.apache.hadoop.hbase.client.LogQueryFilter::Type::LARGE_LOG) + large_log_responses = @admin.getSlowLogResponses(java.util.HashSet.new(server_names), + filter_params) + large_log_responses_arr = [] + for large_log_response in large_log_responses + large_log_responses_arr << large_log_response.toJsonPrettyPrint + end + puts 'Retrieved LargeLog Responses from RegionServers' + puts large_log_responses_arr + end + #---------------------------------------------------------------------------------------------- # Clears SlowLog Responses from RegionServers def clear_slowlog_responses(server_names) diff --git a/hbase-shell/src/main/ruby/shell.rb b/hbase-shell/src/main/ruby/shell.rb index 5b362c2819a..eb013f69589 100644 --- a/hbase-shell/src/main/ruby/shell.rb +++ b/hbase-shell/src/main/ruby/shell.rb @@ -339,6 +339,7 @@ Shell.load_command_group( compaction_switch flush get_slowlog_responses + get_largelog_responses major_compact move split diff --git a/hbase-shell/src/main/ruby/shell/commands/get_largelog_responses.rb b/hbase-shell/src/main/ruby/shell/commands/get_largelog_responses.rb new file mode 100644 index 00000000000..3bdf61457ec --- /dev/null +++ b/hbase-shell/src/main/ruby/shell/commands/get_largelog_responses.rb @@ -0,0 +1,78 @@ +# +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with this +# work for additional information regarding copyright ownership. The ASF +# licenses this file to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +# Retrieve latest large log responses maintained in memory by RegionServers + +module Shell + module Commands + # Retrieve latest large log responses + class GetLargelogResponses < Command + def help + <<-EOF +Retrieve latest LargeLog Responses maintained by each or specific RegionServers. +Specify '*' to include all RS otherwise array of server names for specific +RS. A server name is the host, port plus startcode of a RegionServer. +e.g.: host187.example.com,60020,1289493121758 (find servername in +master ui or when you do detailed status in shell) + +Provide optional filter parameters as Hash. +Default Limit of each server for providing no of large log records is 10. User can specify +more limit by 'LIMIT' param in case more than 10 records should be retrieved. + +Examples: + + hbase> get_largelog_responses '*' => get largelog responses from all RS + hbase> get_largelog_responses '*', {'LIMIT' => 50} => get largelog responses from all RS + with 50 records limit (default limit: 10) + hbase> get_largelog_responses ['SERVER_NAME1', 'SERVER_NAME2'] => get largelog responses from SERVER_NAME1, + SERVER_NAME2 + hbase> get_largelog_responses '*', {'REGION_NAME' => 'hbase:meta,,1'} + => get largelog responses only related to meta + region + hbase> get_largelog_responses '*', {'TABLE_NAME' => 't1'} => get largelog responses only related to t1 table + hbase> get_largelog_responses '*', {'CLIENT_IP' => '192.162.1.40:60225', 'LIMIT' => 100} + => get largelog responses with given client + IP address and get 100 records limit + (default limit: 10) + hbase> get_largelog_responses '*', {'REGION_NAME' => 'hbase:meta,,1', 'TABLE_NAME' => 't1'} + => get largelog responses with given region name + or table name + hbase> get_largelog_responses '*', {'USER' => 'user_name', 'CLIENT_IP' => '192.162.1.40:60225'} + => get largelog responses that match either + provided client IP address or user name + +Sometimes output can be long pretty printed json for user to scroll in +a single screen and hence user might prefer +redirecting output of get_largelog_responses to a file. + +Example: + +echo "get_largelog_responses '*'" | hbase shell > xyz.out 2>&1 + + EOF + end + + def command(server_names, args = {}) + unless args.is_a? Hash + raise 'Filter parameters are not Hash' + end + + admin.get_largelog_responses(server_names, args) + end + end + end +end diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java index b535bb49a20..d70241c5373 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java @@ -65,8 +65,8 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.ResultScanner; -import org.apache.hadoop.hbase.client.SlowLogQueryFilter; -import org.apache.hadoop.hbase.client.SlowLogRecord; +import org.apache.hadoop.hbase.client.LogQueryFilter; +import org.apache.hadoop.hbase.client.OnlineLogRecord; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.security.UserProvider; @@ -81,14 +81,14 @@ import org.apache.hadoop.hbase.thrift2.generated.THRegionLocation; import org.apache.hadoop.hbase.thrift2.generated.TIOError; import org.apache.hadoop.hbase.thrift2.generated.TIllegalArgument; import org.apache.hadoop.hbase.thrift2.generated.TIncrement; +import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter; import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor; +import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TPut; import org.apache.hadoop.hbase.thrift2.generated.TResult; import org.apache.hadoop.hbase.thrift2.generated.TRowMutations; import org.apache.hadoop.hbase.thrift2.generated.TScan; import org.apache.hadoop.hbase.thrift2.generated.TServerName; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogQueryFilter; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TTableName; import org.apache.hadoop.hbase.thrift2.generated.TThriftServerType; @@ -830,15 +830,15 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH } @Override - public List getSlowLogResponses(Set tServerNames, - TSlowLogQueryFilter tSlowLogQueryFilter) throws TIOError, TException { + public List getSlowLogResponses(Set tServerNames, + TLogQueryFilter tLogQueryFilter) throws TIOError, TException { try { Set serverNames = ThriftUtilities.getServerNamesFromThrift(tServerNames); - SlowLogQueryFilter slowLogQueryFilter = - ThriftUtilities.getSlowLogQueryFromThrift(tSlowLogQueryFilter); - List slowLogRecords = - connectionCache.getAdmin().getSlowLogResponses(serverNames, slowLogQueryFilter); - return ThriftUtilities.getSlowLogRecordsFromHBase(slowLogRecords); + LogQueryFilter logQueryFilter = + ThriftUtilities.getSlowLogQueryFromThrift(tLogQueryFilter); + List onlineLogRecords = + connectionCache.getAdmin().getSlowLogResponses(serverNames, logQueryFilter); + return ThriftUtilities.getSlowLogRecordsFromHBase(onlineLogRecords); } catch (IOException e) { throw getTIOError(e); } diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java index 1ac29f3933a..37ac96bb217 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java @@ -53,7 +53,9 @@ import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; +import org.apache.hadoop.hbase.client.LogQueryFilter; import org.apache.hadoop.hbase.client.Mutation; +import org.apache.hadoop.hbase.client.OnlineLogRecord; import org.apache.hadoop.hbase.client.OperationWithAttributes; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.RegionInfo; @@ -61,8 +63,6 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Scan.ReadType; -import org.apache.hadoop.hbase.client.SlowLogQueryFilter; -import org.apache.hadoop.hbase.client.SlowLogRecord; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.exceptions.DeserializationException; @@ -94,16 +94,17 @@ import org.apache.hadoop.hbase.thrift2.generated.THRegionInfo; import org.apache.hadoop.hbase.thrift2.generated.THRegionLocation; import org.apache.hadoop.hbase.thrift2.generated.TIncrement; import org.apache.hadoop.hbase.thrift2.generated.TKeepDeletedCells; +import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter; +import org.apache.hadoop.hbase.thrift2.generated.TLogType; import org.apache.hadoop.hbase.thrift2.generated.TMutation; import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor; +import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TPut; import org.apache.hadoop.hbase.thrift2.generated.TReadType; import org.apache.hadoop.hbase.thrift2.generated.TResult; import org.apache.hadoop.hbase.thrift2.generated.TRowMutations; import org.apache.hadoop.hbase.thrift2.generated.TScan; import org.apache.hadoop.hbase.thrift2.generated.TServerName; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogQueryFilter; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TTableName; import org.apache.hadoop.hbase.thrift2.generated.TTimeRange; @@ -1504,61 +1505,102 @@ public final class ThriftUtilities { .collect(Collectors.toSet()); } - public static TSlowLogQueryFilter getSlowLogQueryFromHBase( - SlowLogQueryFilter slowLogQueryFilter) { - TSlowLogQueryFilter tSlowLogQueryFilter = new TSlowLogQueryFilter(); - tSlowLogQueryFilter.setRegionName(slowLogQueryFilter.getRegionName()); - tSlowLogQueryFilter.setClientAddress(slowLogQueryFilter.getClientAddress()); - tSlowLogQueryFilter.setTableName(slowLogQueryFilter.getTableName()); - tSlowLogQueryFilter.setUserName(slowLogQueryFilter.getUserName()); - tSlowLogQueryFilter.setLimit(slowLogQueryFilter.getLimit()); - return tSlowLogQueryFilter; + public static TLogQueryFilter getSlowLogQueryFromHBase( + LogQueryFilter logQueryFilter) { + TLogQueryFilter tLogQueryFilter = new TLogQueryFilter(); + tLogQueryFilter.setRegionName(logQueryFilter.getRegionName()); + tLogQueryFilter.setClientAddress(logQueryFilter.getClientAddress()); + tLogQueryFilter.setTableName(logQueryFilter.getTableName()); + tLogQueryFilter.setUserName(logQueryFilter.getUserName()); + tLogQueryFilter.setLimit(logQueryFilter.getLimit()); + TLogType tLogType = gettLogTypeFromHBase(logQueryFilter); + tLogQueryFilter.setLogType(tLogType); + return tLogQueryFilter; } - public static SlowLogQueryFilter getSlowLogQueryFromThrift( - TSlowLogQueryFilter tSlowLogQueryFilter) { - SlowLogQueryFilter slowLogQueryFilter = new SlowLogQueryFilter(); - slowLogQueryFilter.setRegionName(tSlowLogQueryFilter.getRegionName()); - slowLogQueryFilter.setClientAddress(tSlowLogQueryFilter.getClientAddress()); - slowLogQueryFilter.setTableName(tSlowLogQueryFilter.getTableName()); - slowLogQueryFilter.setUserName(tSlowLogQueryFilter.getUserName()); - slowLogQueryFilter.setLimit(tSlowLogQueryFilter.getLimit()); - return slowLogQueryFilter; + private static TLogType gettLogTypeFromHBase(final LogQueryFilter logQueryFilter) { + TLogType tLogType; + switch (logQueryFilter.getType()) { + case SLOW_LOG: { + tLogType = TLogType.SLOW_LOG; + break; + } + case LARGE_LOG: { + tLogType = TLogType.LARGE_LOG; + break; + } + default: { + tLogType = TLogType.SLOW_LOG; + } + } + return tLogType; } - public static List getSlowLogRecordsFromHBase( - List slowLogRecords) { - if (CollectionUtils.isEmpty(slowLogRecords)) { + public static LogQueryFilter getSlowLogQueryFromThrift( + TLogQueryFilter tLogQueryFilter) { + LogQueryFilter logQueryFilter = new LogQueryFilter(); + logQueryFilter.setRegionName(tLogQueryFilter.getRegionName()); + logQueryFilter.setClientAddress(tLogQueryFilter.getClientAddress()); + logQueryFilter.setTableName(tLogQueryFilter.getTableName()); + logQueryFilter.setUserName(tLogQueryFilter.getUserName()); + logQueryFilter.setLimit(tLogQueryFilter.getLimit()); + LogQueryFilter.Type type = getLogTypeFromThrift(tLogQueryFilter); + logQueryFilter.setType(type); + return logQueryFilter; + } + + private static LogQueryFilter.Type getLogTypeFromThrift( + final TLogQueryFilter tSlowLogQueryFilter) { + LogQueryFilter.Type type; + switch (tSlowLogQueryFilter.getLogType()) { + case SLOW_LOG: { + type = LogQueryFilter.Type.SLOW_LOG; + break; + } + case LARGE_LOG: { + type = LogQueryFilter.Type.LARGE_LOG; + break; + } + default: { + type = LogQueryFilter.Type.SLOW_LOG; + } + } + return type; + } + + public static List getSlowLogRecordsFromHBase( + List onlineLogRecords) { + if (CollectionUtils.isEmpty(onlineLogRecords)) { return Collections.emptyList(); } - return slowLogRecords.stream() + return onlineLogRecords.stream() .map(slowLogRecord -> { - TSlowLogRecord tSlowLogRecord = new TSlowLogRecord(); - tSlowLogRecord.setCallDetails(slowLogRecord.getCallDetails()); - tSlowLogRecord.setClientAddress(slowLogRecord.getClientAddress()); - tSlowLogRecord.setMethodName(slowLogRecord.getMethodName()); - tSlowLogRecord.setMultiGetsCount(slowLogRecord.getMultiGetsCount()); - tSlowLogRecord.setMultiMutationsCount(slowLogRecord.getMultiMutationsCount()); - tSlowLogRecord.setMultiServiceCalls(slowLogRecord.getMultiServiceCalls()); - tSlowLogRecord.setParam(slowLogRecord.getParam()); - tSlowLogRecord.setProcessingTime(slowLogRecord.getProcessingTime()); - tSlowLogRecord.setQueueTime(slowLogRecord.getQueueTime()); - tSlowLogRecord.setRegionName(slowLogRecord.getRegionName()); - tSlowLogRecord.setResponseSize(slowLogRecord.getResponseSize()); - tSlowLogRecord.setServerClass(slowLogRecord.getServerClass()); - tSlowLogRecord.setStartTime(slowLogRecord.getStartTime()); - tSlowLogRecord.setUserName(slowLogRecord.getUserName()); - return tSlowLogRecord; + TOnlineLogRecord tOnlineLogRecord = new TOnlineLogRecord(); + tOnlineLogRecord.setCallDetails(slowLogRecord.getCallDetails()); + tOnlineLogRecord.setClientAddress(slowLogRecord.getClientAddress()); + tOnlineLogRecord.setMethodName(slowLogRecord.getMethodName()); + tOnlineLogRecord.setMultiGetsCount(slowLogRecord.getMultiGetsCount()); + tOnlineLogRecord.setMultiMutationsCount(slowLogRecord.getMultiMutationsCount()); + tOnlineLogRecord.setMultiServiceCalls(slowLogRecord.getMultiServiceCalls()); + tOnlineLogRecord.setParam(slowLogRecord.getParam()); + tOnlineLogRecord.setProcessingTime(slowLogRecord.getProcessingTime()); + tOnlineLogRecord.setQueueTime(slowLogRecord.getQueueTime()); + tOnlineLogRecord.setRegionName(slowLogRecord.getRegionName()); + tOnlineLogRecord.setResponseSize(slowLogRecord.getResponseSize()); + tOnlineLogRecord.setServerClass(slowLogRecord.getServerClass()); + tOnlineLogRecord.setStartTime(slowLogRecord.getStartTime()); + tOnlineLogRecord.setUserName(slowLogRecord.getUserName()); + return tOnlineLogRecord; }).collect(Collectors.toList()); } - public static List getSlowLogRecordsFromThrift( - List tSlowLogRecords) { - if (CollectionUtils.isEmpty(tSlowLogRecords)) { + public static List getSlowLogRecordsFromThrift( + List tOnlineLogRecords) { + if (CollectionUtils.isEmpty(tOnlineLogRecords)) { return Collections.emptyList(); } - return tSlowLogRecords.stream() - .map(tSlowLogRecord -> new SlowLogRecord.SlowLogRecordBuilder() + return tOnlineLogRecords.stream() + .map(tSlowLogRecord -> new OnlineLogRecord.OnlineLogRecordBuilder() .setCallDetails(tSlowLogRecord.getCallDetails()) .setClientAddress(tSlowLogRecord.getClientAddress()) .setMethodName(tSlowLogRecord.getMethodName()) diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java index 0ac4a74d25d..677adc9f2fb 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftAdmin.java @@ -43,9 +43,9 @@ import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.CompactType; import org.apache.hadoop.hbase.client.CompactionState; import org.apache.hadoop.hbase.client.Connection; +import org.apache.hadoop.hbase.client.LogQueryFilter; +import org.apache.hadoop.hbase.client.OnlineLogRecord; import org.apache.hadoop.hbase.client.RegionInfo; -import org.apache.hadoop.hbase.client.SlowLogQueryFilter; -import org.apache.hadoop.hbase.client.SlowLogRecord; import org.apache.hadoop.hbase.client.SnapshotDescription; import org.apache.hadoop.hbase.client.SnapshotType; import org.apache.hadoop.hbase.client.TableDescriptor; @@ -67,10 +67,10 @@ import org.apache.hadoop.hbase.snapshot.RestoreSnapshotException; import org.apache.hadoop.hbase.thrift2.ThriftUtilities; import org.apache.hadoop.hbase.thrift2.generated.TColumnFamilyDescriptor; import org.apache.hadoop.hbase.thrift2.generated.THBaseService; +import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter; import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor; +import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TServerName; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogQueryFilter; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TTableName; import org.apache.hadoop.hbase.util.Bytes; @@ -1166,15 +1166,15 @@ public class ThriftAdmin implements Admin { } @Override - public List getSlowLogResponses(final Set serverNames, - final SlowLogQueryFilter slowLogQueryFilter) throws IOException { + public List getSlowLogResponses(final Set serverNames, + final LogQueryFilter logQueryFilter) throws IOException { Set tServerNames = ThriftUtilities.getServerNamesFromHBase(serverNames); - TSlowLogQueryFilter tSlowLogQueryFilter = - ThriftUtilities.getSlowLogQueryFromHBase(slowLogQueryFilter); + TLogQueryFilter tLogQueryFilter = + ThriftUtilities.getSlowLogQueryFromHBase(logQueryFilter); try { - List tSlowLogRecords = - client.getSlowLogResponses(tServerNames, tSlowLogQueryFilter); - return ThriftUtilities.getSlowLogRecordsFromThrift(tSlowLogRecords); + List tOnlineLogRecords = + client.getSlowLogResponses(tServerNames, tLogQueryFilter); + return ThriftUtilities.getSlowLogRecordsFromThrift(tOnlineLogRecords); } catch (TException e) { throw new IOException(e); } @@ -1256,4 +1256,5 @@ public class ThriftAdmin implements Admin { getConfiguredNamespacesAndTablesInRSGroup(String groupName) throws IOException { throw new NotImplementedException("setRSGroup not supported in ThriftAdmin"); } + } diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java index 26af3c7d5af..dbc1765245c 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAppend.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TAppend implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAppend"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java index a3f2ae8cd95..a954df55930 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TAuthorization.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TAuthorization implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAuthorization"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java index 6230087a0ad..d8739d96f70 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TBloomFilterType.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.regionserver.BloomType */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TBloomFilterType implements org.apache.thrift.TEnum { /** * Bloomfilters disabled diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java index f2cc3e151d0..641fdacb4cd 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCellVisibility.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TCellVisibility implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TCellVisibility"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java index 3b0890c25f0..9bd9d241b02 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumn.java @@ -12,7 +12,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * in a HBase table by column family and optionally * a column qualifier and timestamp */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TColumn implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumn"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java index 6d1a5e01b00..124887f20f8 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.client.ColumnFamilyDescriptor */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TColumnFamilyDescriptor implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnFamilyDescriptor"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java index 4f438868757..4ea28f67d5a 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnIncrement.java @@ -10,7 +10,7 @@ package org.apache.hadoop.hbase.thrift2.generated; /** * Represents a single cell and the amount to increment it by */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TColumnIncrement implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnIncrement"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java index 8f858d174cb..feeeabe1174 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnValue.java @@ -10,7 +10,7 @@ package org.apache.hadoop.hbase.thrift2.generated; /** * Represents a single cell and its value. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TColumnValue implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnValue"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java index 75edee0921a..da0a8d44ebf 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompareOperator.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.CompareOperator. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TCompareOperator implements org.apache.thrift.TEnum { LESS(0), LESS_OR_EQUAL(1), diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java index 4fce7daaec1..05ed3f12a8a 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TCompressionAlgorithm.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.io.compress.Algorithm */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TCompressionAlgorithm implements org.apache.thrift.TEnum { LZO(0), GZ(1), diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java index 1d5d11755f4..d4c1f924bc2 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TConsistency.java @@ -12,7 +12,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * - STRONG means reads only from primary region * - TIMELINE means reads might return values from secondary region replicas */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TConsistency implements org.apache.thrift.TEnum { STRONG(1), TIMELINE(2); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java index 404006fa878..c28b6077d98 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDataBlockEncoding.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.io.encoding.DataBlockEncoding */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TDataBlockEncoding implements org.apache.thrift.TEnum { /** * Disable data block encoding. diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java index 4c4ecb82637..86d4458d4bb 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDelete.java @@ -33,7 +33,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * by changing the durability. If you don't provide durability, it defaults to * column family's default setting for durability. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TDelete implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TDelete"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java index e14479ee1b5..7b8384d2d9a 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDeleteType.java @@ -12,7 +12,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * - DELETE_COLUMN means exactly one version will be removed, * - DELETE_COLUMNS means previous versions will also be removed. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TDeleteType implements org.apache.thrift.TEnum { DELETE_COLUMN(0), DELETE_COLUMNS(1), diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java index 02af015aa9d..39492513929 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TDurability.java @@ -14,7 +14,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * - SYNC_WAL means write the Mutation to the WAL synchronously, * - FSYNC_WAL means Write the Mutation to the WAL synchronously and force the entries to disk. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TDurability implements org.apache.thrift.TEnum { USE_DEFAULT(0), SKIP_WAL(1), diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java index de066f9d957..551dceb89a2 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TGet.java @@ -20,7 +20,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * If you specify a time range and a timestamp the range is ignored. * Timestamps on TColumns are ignored. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TGet implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGet"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java index 6ffa269d57c..a6fa4e121f3 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THBaseService.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class THBaseService { public interface Iface { @@ -521,12 +521,12 @@ public class THBaseService { * * @param serverNames @param serverNames Server names to get slowlog responses from * - * @param slowLogQueryFilter @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter @param logQueryFilter filter to be used if provided */ - public java.util.List getSlowLogResponses(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter) throws TIOError, org.apache.thrift.TException; + public java.util.List getSlowLogResponses(java.util.Set serverNames, TLogQueryFilter logQueryFilter) throws TIOError, org.apache.thrift.TException; /** - * Clears online slow RPC logs from the provided list of + * Clears online slow/large RPC logs from the provided list of * RegionServers * * @return List of booleans representing if online slowlog response buffer is cleaned @@ -637,7 +637,7 @@ public class THBaseService { public void getClusterId(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getSlowLogResponses(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; + public void getSlowLogResponses(java.util.Set serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; public void clearSlowLogResponses(java.util.Set serverNames, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException; @@ -1897,21 +1897,21 @@ public class THBaseService { throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getClusterId failed: unknown result"); } - public java.util.List getSlowLogResponses(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter) throws TIOError, org.apache.thrift.TException + public java.util.List getSlowLogResponses(java.util.Set serverNames, TLogQueryFilter logQueryFilter) throws TIOError, org.apache.thrift.TException { - send_getSlowLogResponses(serverNames, slowLogQueryFilter); + send_getSlowLogResponses(serverNames, logQueryFilter); return recv_getSlowLogResponses(); } - public void send_getSlowLogResponses(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter) throws org.apache.thrift.TException + public void send_getSlowLogResponses(java.util.Set serverNames, TLogQueryFilter logQueryFilter) throws org.apache.thrift.TException { getSlowLogResponses_args args = new getSlowLogResponses_args(); args.setServerNames(serverNames); - args.setSlowLogQueryFilter(slowLogQueryFilter); + args.setLogQueryFilter(logQueryFilter); sendBase("getSlowLogResponses", args); } - public java.util.List recv_getSlowLogResponses() throws TIOError, org.apache.thrift.TException + public java.util.List recv_getSlowLogResponses() throws TIOError, org.apache.thrift.TException { getSlowLogResponses_result result = new getSlowLogResponses_result(); receiveBase(result, "getSlowLogResponses"); @@ -3615,32 +3615,32 @@ public class THBaseService { } } - public void getSlowLogResponses(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { + public void getSlowLogResponses(java.util.Set serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { checkReady(); - getSlowLogResponses_call method_call = new getSlowLogResponses_call(serverNames, slowLogQueryFilter, resultHandler, this, ___protocolFactory, ___transport); + getSlowLogResponses_call method_call = new getSlowLogResponses_call(serverNames, logQueryFilter, resultHandler, this, ___protocolFactory, ___transport); this.___currentMethod = method_call; ___manager.call(method_call); } - public static class getSlowLogResponses_call extends org.apache.thrift.async.TAsyncMethodCall> { + public static class getSlowLogResponses_call extends org.apache.thrift.async.TAsyncMethodCall> { private java.util.Set serverNames; - private TSlowLogQueryFilter slowLogQueryFilter; - public getSlowLogResponses_call(java.util.Set serverNames, TSlowLogQueryFilter slowLogQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + private TLogQueryFilter logQueryFilter; + public getSlowLogResponses_call(java.util.Set serverNames, TLogQueryFilter logQueryFilter, org.apache.thrift.async.AsyncMethodCallback> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { super(client, protocolFactory, transport, resultHandler, false); this.serverNames = serverNames; - this.slowLogQueryFilter = slowLogQueryFilter; + this.logQueryFilter = logQueryFilter; } public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getSlowLogResponses", org.apache.thrift.protocol.TMessageType.CALL, 0)); getSlowLogResponses_args args = new getSlowLogResponses_args(); args.setServerNames(serverNames); - args.setSlowLogQueryFilter(slowLogQueryFilter); + args.setLogQueryFilter(logQueryFilter); args.write(prot); prot.writeMessageEnd(); } - public java.util.List getResult() throws TIOError, org.apache.thrift.TException { + public java.util.List getResult() throws TIOError, org.apache.thrift.TException { if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { throw new java.lang.IllegalStateException("Method call not finished!"); } @@ -5167,7 +5167,7 @@ public class THBaseService { public getSlowLogResponses_result getResult(I iface, getSlowLogResponses_args args) throws org.apache.thrift.TException { getSlowLogResponses_result result = new getSlowLogResponses_result(); try { - result.success = iface.getSlowLogResponses(args.serverNames, args.slowLogQueryFilter); + result.success = iface.getSlowLogResponses(args.serverNames, args.logQueryFilter); } catch (TIOError io) { result.io = io; } @@ -8383,7 +8383,7 @@ public class THBaseService { } } - public static class getSlowLogResponses extends org.apache.thrift.AsyncProcessFunction> { + public static class getSlowLogResponses extends org.apache.thrift.AsyncProcessFunction> { public getSlowLogResponses() { super("getSlowLogResponses"); } @@ -8392,10 +8392,10 @@ public class THBaseService { return new getSlowLogResponses_args(); } - public org.apache.thrift.async.AsyncMethodCallback> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) { + public org.apache.thrift.async.AsyncMethodCallback> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new org.apache.thrift.async.AsyncMethodCallback>() { - public void onComplete(java.util.List o) { + return new org.apache.thrift.async.AsyncMethodCallback>() { + public void onComplete(java.util.List o) { getSlowLogResponses_result result = new getSlowLogResponses_result(); result.success = o; try { @@ -8443,8 +8443,8 @@ public class THBaseService { return false; } - public void start(I iface, getSlowLogResponses_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { - iface.getSlowLogResponses(args.serverNames, args.slowLogQueryFilter,resultHandler); + public void start(I iface, getSlowLogResponses_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws org.apache.thrift.TException { + iface.getSlowLogResponses(args.serverNames, args.logQueryFilter,resultHandler); } } @@ -53224,7 +53224,7 @@ public class THBaseService { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getSlowLogResponses_args"); private static final org.apache.thrift.protocol.TField SERVER_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("serverNames", org.apache.thrift.protocol.TType.SET, (short)1); - private static final org.apache.thrift.protocol.TField SLOW_LOG_QUERY_FILTER_FIELD_DESC = new org.apache.thrift.protocol.TField("slowLogQueryFilter", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField LOG_QUERY_FILTER_FIELD_DESC = new org.apache.thrift.protocol.TField("logQueryFilter", org.apache.thrift.protocol.TType.STRUCT, (short)2); private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getSlowLogResponses_argsStandardSchemeFactory(); private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getSlowLogResponses_argsTupleSchemeFactory(); @@ -53234,9 +53234,9 @@ public class THBaseService { */ public @org.apache.thrift.annotation.Nullable java.util.Set serverNames; // required /** - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided */ - public @org.apache.thrift.annotation.Nullable TSlowLogQueryFilter slowLogQueryFilter; // required + public @org.apache.thrift.annotation.Nullable TLogQueryFilter logQueryFilter; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -53245,9 +53245,9 @@ public class THBaseService { */ SERVER_NAMES((short)1, "serverNames"), /** - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided */ - SLOW_LOG_QUERY_FILTER((short)2, "slowLogQueryFilter"); + LOG_QUERY_FILTER((short)2, "logQueryFilter"); private static final java.util.Map byName = new java.util.HashMap(); @@ -53265,8 +53265,8 @@ public class THBaseService { switch(fieldId) { case 1: // SERVER_NAMES return SERVER_NAMES; - case 2: // SLOW_LOG_QUERY_FILTER - return SLOW_LOG_QUERY_FILTER; + case 2: // LOG_QUERY_FILTER + return LOG_QUERY_FILTER; default: return null; } @@ -53314,8 +53314,8 @@ public class THBaseService { tmpMap.put(_Fields.SERVER_NAMES, new org.apache.thrift.meta_data.FieldMetaData("serverNames", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TServerName.class)))); - tmpMap.put(_Fields.SLOW_LOG_QUERY_FILTER, new org.apache.thrift.meta_data.FieldMetaData("slowLogQueryFilter", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSlowLogQueryFilter.class))); + tmpMap.put(_Fields.LOG_QUERY_FILTER, new org.apache.thrift.meta_data.FieldMetaData("logQueryFilter", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TLogQueryFilter.class))); metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getSlowLogResponses_args.class, metaDataMap); } @@ -53325,11 +53325,11 @@ public class THBaseService { public getSlowLogResponses_args( java.util.Set serverNames, - TSlowLogQueryFilter slowLogQueryFilter) + TLogQueryFilter logQueryFilter) { this(); this.serverNames = serverNames; - this.slowLogQueryFilter = slowLogQueryFilter; + this.logQueryFilter = logQueryFilter; } /** @@ -53343,8 +53343,8 @@ public class THBaseService { } this.serverNames = __this__serverNames; } - if (other.isSetSlowLogQueryFilter()) { - this.slowLogQueryFilter = new TSlowLogQueryFilter(other.slowLogQueryFilter); + if (other.isSetLogQueryFilter()) { + this.logQueryFilter = new TLogQueryFilter(other.logQueryFilter); } } @@ -53355,7 +53355,7 @@ public class THBaseService { @Override public void clear() { this.serverNames = null; - this.slowLogQueryFilter = null; + this.logQueryFilter = null; } public int getServerNamesSize() { @@ -53406,33 +53406,33 @@ public class THBaseService { } /** - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided */ @org.apache.thrift.annotation.Nullable - public TSlowLogQueryFilter getSlowLogQueryFilter() { - return this.slowLogQueryFilter; + public TLogQueryFilter getLogQueryFilter() { + return this.logQueryFilter; } /** - * @param slowLogQueryFilter filter to be used if provided + * @param logQueryFilter filter to be used if provided */ - public getSlowLogResponses_args setSlowLogQueryFilter(@org.apache.thrift.annotation.Nullable TSlowLogQueryFilter slowLogQueryFilter) { - this.slowLogQueryFilter = slowLogQueryFilter; + public getSlowLogResponses_args setLogQueryFilter(@org.apache.thrift.annotation.Nullable TLogQueryFilter logQueryFilter) { + this.logQueryFilter = logQueryFilter; return this; } - public void unsetSlowLogQueryFilter() { - this.slowLogQueryFilter = null; + public void unsetLogQueryFilter() { + this.logQueryFilter = null; } - /** Returns true if field slowLogQueryFilter is set (has been assigned a value) and false otherwise */ - public boolean isSetSlowLogQueryFilter() { - return this.slowLogQueryFilter != null; + /** Returns true if field logQueryFilter is set (has been assigned a value) and false otherwise */ + public boolean isSetLogQueryFilter() { + return this.logQueryFilter != null; } - public void setSlowLogQueryFilterIsSet(boolean value) { + public void setLogQueryFilterIsSet(boolean value) { if (!value) { - this.slowLogQueryFilter = null; + this.logQueryFilter = null; } } @@ -53446,11 +53446,11 @@ public class THBaseService { } break; - case SLOW_LOG_QUERY_FILTER: + case LOG_QUERY_FILTER: if (value == null) { - unsetSlowLogQueryFilter(); + unsetLogQueryFilter(); } else { - setSlowLogQueryFilter((TSlowLogQueryFilter)value); + setLogQueryFilter((TLogQueryFilter)value); } break; @@ -53463,8 +53463,8 @@ public class THBaseService { case SERVER_NAMES: return getServerNames(); - case SLOW_LOG_QUERY_FILTER: - return getSlowLogQueryFilter(); + case LOG_QUERY_FILTER: + return getLogQueryFilter(); } throw new java.lang.IllegalStateException(); @@ -53479,8 +53479,8 @@ public class THBaseService { switch (field) { case SERVER_NAMES: return isSetServerNames(); - case SLOW_LOG_QUERY_FILTER: - return isSetSlowLogQueryFilter(); + case LOG_QUERY_FILTER: + return isSetLogQueryFilter(); } throw new java.lang.IllegalStateException(); } @@ -53509,12 +53509,12 @@ public class THBaseService { return false; } - boolean this_present_slowLogQueryFilter = true && this.isSetSlowLogQueryFilter(); - boolean that_present_slowLogQueryFilter = true && that.isSetSlowLogQueryFilter(); - if (this_present_slowLogQueryFilter || that_present_slowLogQueryFilter) { - if (!(this_present_slowLogQueryFilter && that_present_slowLogQueryFilter)) + boolean this_present_logQueryFilter = true && this.isSetLogQueryFilter(); + boolean that_present_logQueryFilter = true && that.isSetLogQueryFilter(); + if (this_present_logQueryFilter || that_present_logQueryFilter) { + if (!(this_present_logQueryFilter && that_present_logQueryFilter)) return false; - if (!this.slowLogQueryFilter.equals(that.slowLogQueryFilter)) + if (!this.logQueryFilter.equals(that.logQueryFilter)) return false; } @@ -53529,9 +53529,9 @@ public class THBaseService { if (isSetServerNames()) hashCode = hashCode * 8191 + serverNames.hashCode(); - hashCode = hashCode * 8191 + ((isSetSlowLogQueryFilter()) ? 131071 : 524287); - if (isSetSlowLogQueryFilter()) - hashCode = hashCode * 8191 + slowLogQueryFilter.hashCode(); + hashCode = hashCode * 8191 + ((isSetLogQueryFilter()) ? 131071 : 524287); + if (isSetLogQueryFilter()) + hashCode = hashCode * 8191 + logQueryFilter.hashCode(); return hashCode; } @@ -53554,12 +53554,12 @@ public class THBaseService { return lastComparison; } } - lastComparison = java.lang.Boolean.valueOf(isSetSlowLogQueryFilter()).compareTo(other.isSetSlowLogQueryFilter()); + lastComparison = java.lang.Boolean.valueOf(isSetLogQueryFilter()).compareTo(other.isSetLogQueryFilter()); if (lastComparison != 0) { return lastComparison; } - if (isSetSlowLogQueryFilter()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.slowLogQueryFilter, other.slowLogQueryFilter); + if (isSetLogQueryFilter()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.logQueryFilter, other.logQueryFilter); if (lastComparison != 0) { return lastComparison; } @@ -53593,11 +53593,11 @@ public class THBaseService { } first = false; if (!first) sb.append(", "); - sb.append("slowLogQueryFilter:"); - if (this.slowLogQueryFilter == null) { + sb.append("logQueryFilter:"); + if (this.logQueryFilter == null) { sb.append("null"); } else { - sb.append(this.slowLogQueryFilter); + sb.append(this.logQueryFilter); } first = false; sb.append(")"); @@ -53607,8 +53607,8 @@ public class THBaseService { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (slowLogQueryFilter != null) { - slowLogQueryFilter.validate(); + if (logQueryFilter != null) { + logQueryFilter.validate(); } } @@ -53665,11 +53665,11 @@ public class THBaseService { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 2: // SLOW_LOG_QUERY_FILTER + case 2: // LOG_QUERY_FILTER if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.slowLogQueryFilter = new TSlowLogQueryFilter(); - struct.slowLogQueryFilter.read(iprot); - struct.setSlowLogQueryFilterIsSet(true); + struct.logQueryFilter = new TLogQueryFilter(); + struct.logQueryFilter.read(iprot); + struct.setLogQueryFilterIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -53701,9 +53701,9 @@ public class THBaseService { } oprot.writeFieldEnd(); } - if (struct.slowLogQueryFilter != null) { - oprot.writeFieldBegin(SLOW_LOG_QUERY_FILTER_FIELD_DESC); - struct.slowLogQueryFilter.write(oprot); + if (struct.logQueryFilter != null) { + oprot.writeFieldBegin(LOG_QUERY_FILTER_FIELD_DESC); + struct.logQueryFilter.write(oprot); oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -53727,7 +53727,7 @@ public class THBaseService { if (struct.isSetServerNames()) { optionals.set(0); } - if (struct.isSetSlowLogQueryFilter()) { + if (struct.isSetLogQueryFilter()) { optionals.set(1); } oprot.writeBitSet(optionals, 2); @@ -53740,8 +53740,8 @@ public class THBaseService { } } } - if (struct.isSetSlowLogQueryFilter()) { - struct.slowLogQueryFilter.write(oprot); + if (struct.isSetLogQueryFilter()) { + struct.logQueryFilter.write(oprot); } } @@ -53764,9 +53764,9 @@ public class THBaseService { struct.setServerNamesIsSet(true); } if (incoming.get(1)) { - struct.slowLogQueryFilter = new TSlowLogQueryFilter(); - struct.slowLogQueryFilter.read(iprot); - struct.setSlowLogQueryFilterIsSet(true); + struct.logQueryFilter = new TLogQueryFilter(); + struct.logQueryFilter.read(iprot); + struct.setLogQueryFilterIsSet(true); } } } @@ -53785,7 +53785,7 @@ public class THBaseService { private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new getSlowLogResponses_resultStandardSchemeFactory(); private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new getSlowLogResponses_resultTupleSchemeFactory(); - public @org.apache.thrift.annotation.Nullable java.util.List success; // required + public @org.apache.thrift.annotation.Nullable java.util.List success; // required public @org.apache.thrift.annotation.Nullable TIOError io; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -53857,7 +53857,7 @@ public class THBaseService { java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSlowLogRecord.class)))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TOnlineLogRecord.class)))); tmpMap.put(_Fields.IO, new org.apache.thrift.meta_data.FieldMetaData("io", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TIOError.class))); metaDataMap = java.util.Collections.unmodifiableMap(tmpMap); @@ -53868,7 +53868,7 @@ public class THBaseService { } public getSlowLogResponses_result( - java.util.List success, + java.util.List success, TIOError io) { this(); @@ -53881,9 +53881,9 @@ public class THBaseService { */ public getSlowLogResponses_result(getSlowLogResponses_result other) { if (other.isSetSuccess()) { - java.util.List __this__success = new java.util.ArrayList(other.success.size()); - for (TSlowLogRecord other_element : other.success) { - __this__success.add(new TSlowLogRecord(other_element)); + java.util.List __this__success = new java.util.ArrayList(other.success.size()); + for (TOnlineLogRecord other_element : other.success) { + __this__success.add(new TOnlineLogRecord(other_element)); } this.success = __this__success; } @@ -53907,23 +53907,23 @@ public class THBaseService { } @org.apache.thrift.annotation.Nullable - public java.util.Iterator getSuccessIterator() { + public java.util.Iterator getSuccessIterator() { return (this.success == null) ? null : this.success.iterator(); } - public void addToSuccess(TSlowLogRecord elem) { + public void addToSuccess(TOnlineLogRecord elem) { if (this.success == null) { - this.success = new java.util.ArrayList(); + this.success = new java.util.ArrayList(); } this.success.add(elem); } @org.apache.thrift.annotation.Nullable - public java.util.List getSuccess() { + public java.util.List getSuccess() { return this.success; } - public getSlowLogResponses_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List success) { + public getSlowLogResponses_result setSuccess(@org.apache.thrift.annotation.Nullable java.util.List success) { this.success = success; return this; } @@ -53974,7 +53974,7 @@ public class THBaseService { if (value == null) { unsetSuccess(); } else { - setSuccess((java.util.List)value); + setSuccess((java.util.List)value); } break; @@ -54179,11 +54179,11 @@ public class THBaseService { if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { org.apache.thrift.protocol.TList _list358 = iprot.readListBegin(); - struct.success = new java.util.ArrayList(_list358.size); - @org.apache.thrift.annotation.Nullable TSlowLogRecord _elem359; + struct.success = new java.util.ArrayList(_list358.size); + @org.apache.thrift.annotation.Nullable TOnlineLogRecord _elem359; for (int _i360 = 0; _i360 < _list358.size; ++_i360) { - _elem359 = new TSlowLogRecord(); + _elem359 = new TOnlineLogRecord(); _elem359.read(iprot); struct.success.add(_elem359); } @@ -54222,7 +54222,7 @@ public class THBaseService { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (TSlowLogRecord _iter361 : struct.success) + for (TOnlineLogRecord _iter361 : struct.success) { _iter361.write(oprot); } @@ -54263,7 +54263,7 @@ public class THBaseService { if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (TSlowLogRecord _iter362 : struct.success) + for (TOnlineLogRecord _iter362 : struct.success) { _iter362.write(oprot); } @@ -54281,11 +54281,11 @@ public class THBaseService { if (incoming.get(0)) { { org.apache.thrift.protocol.TList _list363 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new java.util.ArrayList(_list363.size); - @org.apache.thrift.annotation.Nullable TSlowLogRecord _elem364; + struct.success = new java.util.ArrayList(_list363.size); + @org.apache.thrift.annotation.Nullable TOnlineLogRecord _elem364; for (int _i365 = 0; _i365 < _list363.size; ++_i365) { - _elem364 = new TSlowLogRecord(); + _elem364 = new TOnlineLogRecord(); _elem364.read(iprot); struct.success.add(_elem364); } diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java index d00eb625014..956cfcdd146 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionInfo.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class THRegionInfo implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("THRegionInfo"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java index 52f846cb2f2..cf21d8c3e2e 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/THRegionLocation.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class THRegionLocation implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("THRegionLocation"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java index d8c27ff6a93..d7f5b170e15 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIOError.java @@ -12,7 +12,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * to the HBase master or a HBase region server. Also used to return * more general HBase error conditions. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TIOError extends org.apache.thrift.TException implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIOError"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java index 6996ce43e45..d79e2424e8b 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIllegalArgument.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * A TIllegalArgument exception indicates an illegal or invalid * argument was passed into a procedure. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TIllegalArgument extends org.apache.thrift.TException implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIllegalArgument"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java index 0d3d460a690..a6758f8ac8a 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TIncrement.java @@ -14,7 +14,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * by changing the durability. If you don't provide durability, it defaults to * column family's default setting for durability. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TIncrement implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TIncrement"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java index 2f36d428ac5..2ae03f7f53b 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TKeepDeletedCells.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.KeepDeletedCells */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TKeepDeletedCells implements org.apache.thrift.TEnum { /** * Deleted Cells are not retained. diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogQueryFilter.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java similarity index 79% rename from hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogQueryFilter.java rename to hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java index bd6f4cc854c..f3949932e62 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogQueryFilter.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TLogQueryFilter.java @@ -9,26 +9,32 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) /** * Thrift wrapper around - * org.apache.hadoop.hbase.client.SlowLogQueryFilter + * org.apache.hadoop.hbase.client.LogQueryFilter */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") -public class TSlowLogQueryFilter implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TSlowLogQueryFilter"); +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") +public class TLogQueryFilter implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TLogQueryFilter"); private static final org.apache.thrift.protocol.TField REGION_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("regionName", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField CLIENT_ADDRESS_FIELD_DESC = new org.apache.thrift.protocol.TField("clientAddress", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)3); private static final org.apache.thrift.protocol.TField USER_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("userName", org.apache.thrift.protocol.TType.STRING, (short)4); private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)5); + private static final org.apache.thrift.protocol.TField LOG_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("logType", org.apache.thrift.protocol.TType.I32, (short)6); - private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TSlowLogQueryFilterStandardSchemeFactory(); - private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TSlowLogQueryFilterTupleSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TLogQueryFilterStandardSchemeFactory(); + private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TLogQueryFilterTupleSchemeFactory(); public @org.apache.thrift.annotation.Nullable java.lang.String regionName; // optional public @org.apache.thrift.annotation.Nullable java.lang.String clientAddress; // optional public @org.apache.thrift.annotation.Nullable java.lang.String tableName; // optional public @org.apache.thrift.annotation.Nullable java.lang.String userName; // optional public int limit; // optional + /** + * + * @see TLogType + */ + public @org.apache.thrift.annotation.Nullable TLogType logType; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { @@ -36,7 +42,12 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBase byName = new java.util.HashMap(); @@ -62,6 +73,8 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBase metaDataMap; static { java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); @@ -119,19 +132,23 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBaseother. */ - public TSlowLogQueryFilter(TSlowLogQueryFilter other) { + public TLogQueryFilter(TLogQueryFilter other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetRegionName()) { this.regionName = other.regionName; @@ -146,10 +163,13 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBase { + private static class TLogQueryFilterStandardScheme extends org.apache.thrift.scheme.StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, TSlowLogQueryFilter struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, TLogQueryFilter struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -672,6 +773,14 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBase { + private static class TLogQueryFilterTupleScheme extends org.apache.thrift.scheme.TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, TSlowLogQueryFilter struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, TLogQueryFilter struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; java.util.BitSet optionals = new java.util.BitSet(); if (struct.isSetRegionName()) { @@ -753,7 +869,10 @@ public class TSlowLogQueryFilter implements org.apache.thrift.TBase { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TMutation"); private static final org.apache.thrift.protocol.TField PUT_FIELD_DESC = new org.apache.thrift.protocol.TField("put", org.apache.thrift.protocol.TType.STRUCT, (short)1); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java index 76c647eb034..e227bde2fcd 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TNamespaceDescriptor.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.NamespaceDescriptor */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TNamespaceDescriptor implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TNamespaceDescriptor"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogRecord.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java similarity index 94% rename from hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogRecord.java rename to hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java index 2619c0609c6..47b2eb019ae 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TSlowLogRecord.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TOnlineLogRecord.java @@ -9,11 +9,11 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) /** * Thrift wrapper around - * org.apache.hadoop.hbase.client.SlowLogRecord + * org.apache.hadoop.hbase.client.OnlineLogRecordrd */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") -public class TSlowLogRecord implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TSlowLogRecord"); +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") +public class TOnlineLogRecord implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TOnlineLogRecord"); private static final org.apache.thrift.protocol.TField START_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("startTime", org.apache.thrift.protocol.TType.I64, (short)1); private static final org.apache.thrift.protocol.TField PROCESSING_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("processingTime", org.apache.thrift.protocol.TType.I32, (short)2); @@ -30,8 +30,8 @@ public class TSlowLogRecord implements org.apache.thrift.TBaseother. */ - public TSlowLogRecord(TSlowLogRecord other) { + public TOnlineLogRecord(TOnlineLogRecord other) { __isset_bitfield = other.__isset_bitfield; this.startTime = other.startTime; this.processingTime = other.processingTime; @@ -268,8 +268,8 @@ public class TSlowLogRecord implements org.apache.thrift.TBase { + private static class TOnlineLogRecordStandardScheme extends org.apache.thrift.scheme.StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, TSlowLogRecord struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, TOnlineLogRecord struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -1499,7 +1499,7 @@ public class TSlowLogRecord implements org.apache.thrift.TBase { + private static class TOnlineLogRecordTupleScheme extends org.apache.thrift.scheme.TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, TSlowLogRecord struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, TOnlineLogRecord struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot; oprot.writeI64(struct.startTime); oprot.writeI32(struct.processingTime); @@ -1602,7 +1602,7 @@ public class TSlowLogRecord implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TPut"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java index 906bafedf4f..82d62fe7672 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TReadType.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TReadType implements org.apache.thrift.TEnum { DEFAULT(1), STREAM(2), diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java index 5e69fed5c38..7c6a30d5393 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TResult.java @@ -10,7 +10,7 @@ package org.apache.hadoop.hbase.thrift2.generated; /** * if no Result is found, row and columnValues will not be set. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TResult implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TResult"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java index 91165d13fae..d1288490cfd 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TRowMutations.java @@ -10,7 +10,7 @@ package org.apache.hadoop.hbase.thrift2.generated; /** * A TRowMutations object is used to apply a number of Mutations to a single row. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TRowMutations implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TRowMutations"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java index 98826bfdbf3..6178aef49a2 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TScan.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Any timestamps in the columns are ignored but the colFamTimeRangeMap included, use timeRange to select by timestamp. * Max versions defaults to 1. */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TScan implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TScan"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java index 429f0d25520..672372b61c1 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TServerName.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TServerName implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TServerName"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java index 28d10c0b8ae..4276fb2f7a8 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableDescriptor.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.client.TableDescriptor */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TTableDescriptor implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTableDescriptor"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java index d97542ad820..c78025d421d 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTableName.java @@ -11,7 +11,7 @@ package org.apache.hadoop.hbase.thrift2.generated; * Thrift wrapper around * org.apache.hadoop.hbase.TableName */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TTableName implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTableName"); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java index d04063410bb..470fb9c1a8c 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TThriftServerType.java @@ -10,7 +10,7 @@ package org.apache.hadoop.hbase.thrift2.generated; /** * Specify type of thrift server: thrift and thrift2 */ -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public enum TThriftServerType implements org.apache.thrift.TEnum { ONE(1), TWO(2); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java index 9c12bb264a2..a4ae0a58d41 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TTimeRange.java @@ -7,7 +7,7 @@ package org.apache.hadoop.hbase.thrift2.generated; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"}) -@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-03-21") +@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-01") public class TTimeRange implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TTimeRange"); diff --git a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift index 352395e53a7..640e8a97f26 100644 --- a/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift +++ b/hbase-thrift/src/main/resources/org/apache/hadoop/hbase/thrift2/hbase.thrift @@ -454,24 +454,30 @@ struct TNamespaceDescriptor { 2: optional map configuration } +enum TLogType { + SLOW_LOG = 1, + LARGE_LOG = 2 +} /** * Thrift wrapper around - * org.apache.hadoop.hbase.client.SlowLogQueryFilter + * org.apache.hadoop.hbase.client.LogQueryFilter */ -struct TSlowLogQueryFilter { +struct TLogQueryFilter { 1: optional string regionName 2: optional string clientAddress 3: optional string tableName 4: optional string userName 5: optional i32 limit = 10 + 6: optional TLogType logType = 1 } + /** * Thrift wrapper around - * org.apache.hadoop.hbase.client.SlowLogRecord + * org.apache.hadoop.hbase.client.OnlineLogRecordrd */ -struct TSlowLogRecord { +struct TOnlineLogRecord { 1: required i64 startTime 2: required i32 processingTime 3: required i32 queueTime @@ -1099,15 +1105,15 @@ service THBaseService { * @return online slowlog response list * @throws TIOError if a remote or network exception occurs */ - list getSlowLogResponses( + list getSlowLogResponses( /** @param serverNames Server names to get slowlog responses from */ 1: set serverNames - /** @param slowLogQueryFilter filter to be used if provided */ - 2: TSlowLogQueryFilter slowLogQueryFilter + /** @param logQueryFilter filter to be used if provided */ + 2: TLogQueryFilter logQueryFilter ) throws (1: TIOError io) /** - * Clears online slow RPC logs from the provided list of + * Clears online slow/large RPC logs from the provided list of * RegionServers * * @return List of booleans representing if online slowlog response buffer is cleaned diff --git a/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java b/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java index 1b0819fee35..ca33d76f43c 100644 --- a/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java +++ b/hbase-thrift/src/test/java/org/apache/hadoop/hbase/thrift2/TestThriftHBaseServiceHandler.java @@ -97,16 +97,16 @@ import org.apache.hadoop.hbase.thrift2.generated.THBaseService; import org.apache.hadoop.hbase.thrift2.generated.TIOError; import org.apache.hadoop.hbase.thrift2.generated.TIllegalArgument; import org.apache.hadoop.hbase.thrift2.generated.TIncrement; +import org.apache.hadoop.hbase.thrift2.generated.TLogQueryFilter; import org.apache.hadoop.hbase.thrift2.generated.TMutation; import org.apache.hadoop.hbase.thrift2.generated.TNamespaceDescriptor; +import org.apache.hadoop.hbase.thrift2.generated.TOnlineLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TPut; import org.apache.hadoop.hbase.thrift2.generated.TReadType; import org.apache.hadoop.hbase.thrift2.generated.TResult; import org.apache.hadoop.hbase.thrift2.generated.TRowMutations; import org.apache.hadoop.hbase.thrift2.generated.TScan; import org.apache.hadoop.hbase.thrift2.generated.TServerName; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogQueryFilter; -import org.apache.hadoop.hbase.thrift2.generated.TSlowLogRecord; import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TTableName; import org.apache.hadoop.hbase.thrift2.generated.TThriftServerType; @@ -1765,11 +1765,11 @@ public class TestThriftHBaseServiceHandler { List clearedResponses = thriftHBaseServiceHandler.clearSlowLogResponses(tServerNames); clearedResponses.forEach(Assert::assertTrue); - TSlowLogQueryFilter tSlowLogQueryFilter = new TSlowLogQueryFilter(); - tSlowLogQueryFilter.setLimit(15); - List tSlowLogRecords = - thriftHBaseServiceHandler.getSlowLogResponses(tServerNames, tSlowLogQueryFilter); - assertEquals(tSlowLogRecords.size(), 0); + TLogQueryFilter tLogQueryFilter = new TLogQueryFilter(); + tLogQueryFilter.setLimit(15); + List tLogRecords = + thriftHBaseServiceHandler.getSlowLogResponses(tServerNames, tLogQueryFilter); + assertEquals(tLogRecords.size(), 0); } public static class DelayingRegionObserver implements RegionCoprocessor, RegionObserver {