From ffece1617ad90853f91a44d571f1b5ad75c3544b Mon Sep 17 00:00:00 2001 From: peng-yongsheng <8082209@qq.com> Date: Mon, 20 Aug 2018 11:01:33 +0800 Subject: [PATCH] Indicator analysis test successfully. --- oap-server/server-core/pom.xml | 5 - .../core/analysis/DispatcherManager.java | 9 ++ .../endpoint/EndpointAvgIndicator.java | 27 ++-- .../endpoint/EndpointDispatcher.java | 3 +- .../endpoint/EndpointPercentIndicator.java | 25 +-- .../InstanceJvmCpuIndicator.java | 125 ++++++++++++++ .../ServiceInstanceJVMCPUDispatcher.java | 45 ++++++ .../InstanceJvmGcTimeIndicator.java | 125 ++++++++++++++ .../ServiceInstanceJVMGCDispatcher.java | 45 ++++++ .../InstanceJvmMemoryMaxIndicator.java | 125 ++++++++++++++ .../ServiceInstanceJVMMemoryDispatcher.java | 45 ++++++ .../InstanceJvmMemoryPoolMaxIndicator.java | 125 ++++++++++++++ ...erviceInstanceJVMMemoryPoolDispatcher.java | 45 ++++++ .../indicator/DoubleAvgIndicator.java | 53 ++++++ .../core/analysis/indicator/Indicator.java | 2 + ...vgIndicator.java => LongAvgIndicator.java} | 8 +- .../analysis/indicator/PercentIndicator.java | 13 +- .../oap/server/core/source/DetectPoint.java | 26 +++ .../oap/server/core/source/Endpoint.java | 3 +- .../server/core/source/EndpointRelation.java | 5 +- .../oap/server/core/source/GCPhrase.java | 26 +++ .../server/core/source/MemoryPoolType.java | 26 +++ .../oap/server/core/source/RequestType.java | 26 +++ .../oap/server/core/source/Scope.java | 3 +- .../oap/server/core/source/Service.java | 12 +- .../core/source/ServiceInstanceJVMCPU.java | 38 +++++ .../core/source/ServiceInstanceJVMGC.java | 40 +++++ .../core/source/ServiceInstanceJVMMemory.java | 40 +++++ .../source/ServiceInstanceJVMMemoryPool.java | 40 +++++ ...dicator.java => TestLongAvgIndicator.java} | 4 +- .../server/library/util/TimeBucketUtils.java | 75 +++++++++ oap-server/server-receiver-plugin/pom.xml | 6 + .../pom.xml | 8 - .../skywalking-jvm-receiver-plugin/pom.xml | 32 ++++ .../receiver/jvm/module/JVMModule.java} | 18 ++- .../jvm/provider/JVMModuleProvider.java | 59 +++++++ .../handler/JVMMetricsServiceHandler.java | 152 ++++++++++++++++++ ...ing.oap.server.library.module.ModuleDefine | 19 +++ ...g.oap.server.library.module.ModuleProvider | 19 +++ .../JVMMetricsServiceHandlerMainTest.java | 137 ++++++++++++++++ .../src/test/resources/log4j2.xml | 31 ++++ oap-server/server-starter/pom.xml | 5 + .../src/main/resources/application.yml | 2 + ...lasticSearchColumnTypeMappingTestCase.java | 2 +- 44 files changed, 1613 insertions(+), 66 deletions(-) create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/InstanceJvmCpuIndicator.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/ServiceInstanceJVMCPUDispatcher.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/InstanceJvmGcTimeIndicator.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/ServiceInstanceJVMGCDispatcher.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/InstanceJvmMemoryMaxIndicator.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/ServiceInstanceJVMMemoryDispatcher.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/InstanceJvmMemoryPoolMaxIndicator.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/ServiceInstanceJVMMemoryPoolDispatcher.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/DoubleAvgIndicator.java rename oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/{AvgIndicator.java => LongAvgIndicator.java} (88%) create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/DetectPoint.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/GCPhrase.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/MemoryPoolType.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/RequestType.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMCPU.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMGC.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemory.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemoryPool.java rename oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/{TestAvgIndicator.java => TestLongAvgIndicator.java} (94%) create mode 100644 oap-server/server-library/library-util/src/main/java/org/apache/skywalking/oap/server/library/util/TimeBucketUtils.java create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/pom.xml rename oap-server/{server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/service/ServiceDispatcher.java => server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/module/JVMModule.java} (63%) create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/JVMModuleProvider.java create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandler.java create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleDefine create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandlerMainTest.java create mode 100644 oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/resources/log4j2.xml diff --git a/oap-server/server-core/pom.xml b/oap-server/server-core/pom.xml index ca6ac7abe..5ffad8da7 100644 --- a/oap-server/server-core/pom.xml +++ b/oap-server/server-core/pom.xml @@ -51,11 +51,6 @@ library-server ${project.version} - - org.apache.skywalking - apm-network - ${project.version} - org.apache.skywalking apm-datacarrier diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/DispatcherManager.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/DispatcherManager.java index 3579ad8bf..b8953c604 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/DispatcherManager.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/DispatcherManager.java @@ -20,6 +20,10 @@ package org.apache.skywalking.oap.server.core.analysis; import java.util.*; import org.apache.skywalking.oap.server.core.analysis.generated.endpoint.EndpointDispatcher; +import org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmcpu.ServiceInstanceJVMCPUDispatcher; +import org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmgc.ServiceInstanceJVMGCDispatcher; +import org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemory.ServiceInstanceJVMMemoryDispatcher; +import org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemorypool.ServiceInstanceJVMMemoryPoolDispatcher; import org.apache.skywalking.oap.server.core.source.Scope; import org.slf4j.*; @@ -35,6 +39,11 @@ public class DispatcherManager { public DispatcherManager() { this.dispatcherMap = new HashMap<>(); this.dispatcherMap.put(Scope.Endpoint, new EndpointDispatcher()); + + this.dispatcherMap.put(Scope.ServiceInstanceJVMCPU, new ServiceInstanceJVMCPUDispatcher()); + this.dispatcherMap.put(Scope.ServiceInstanceJVMGC, new ServiceInstanceJVMGCDispatcher()); + this.dispatcherMap.put(Scope.ServiceInstanceJVMMemory, new ServiceInstanceJVMMemoryDispatcher()); + this.dispatcherMap.put(Scope.ServiceInstanceJVMMemoryPool, new ServiceInstanceJVMMemoryPoolDispatcher()); } public SourceDispatcher getDispatcher(Scope scope) { diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointAvgIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointAvgIndicator.java index 6763c08e2..bc2834564 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointAvgIndicator.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointAvgIndicator.java @@ -20,12 +20,13 @@ package org.apache.skywalking.oap.server.core.analysis.generated.endpoint; import java.util.*; import lombok.*; -import org.apache.skywalking.oap.server.core.analysis.indicator.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.LongAvgIndicator; import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; -import org.apache.skywalking.oap.server.core.storage.annotation.*; import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; /** * This class is auto generated. Please don't change this class manually. @@ -35,14 +36,16 @@ import org.apache.skywalking.oap.server.core.storage.StorageBuilder; @IndicatorType @StreamData @StorageEntity(name = "endpoint_avg", builder = EndpointAvgIndicator.Builder.class) -public class EndpointAvgIndicator extends AvgIndicator { +public class EndpointAvgIndicator extends LongAvgIndicator { @Setter @Getter @Column(columnName = "id") private int id; @Setter @Getter @Column(columnName = "service_id") private int serviceId; @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; @Override public String id() { - return String.valueOf(id); + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; } @Override public int hashCode() { @@ -52,7 +55,6 @@ public class EndpointAvgIndicator extends AvgIndicator { return result; } - @Override public boolean equals(Object obj) { if (this == obj) return true; @@ -70,7 +72,6 @@ public class EndpointAvgIndicator extends AvgIndicator { return true; } - @Override public RemoteData.Builder serialize() { RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); @@ -116,13 +117,13 @@ public class EndpointAvgIndicator extends AvgIndicator { @Override public EndpointAvgIndicator map2Data(Map dbMap) { EndpointAvgIndicator indicator = new EndpointAvgIndicator(); - indicator.setId((int)dbMap.get("id")); - indicator.setServiceId((int)dbMap.get("service_id")); - indicator.setServiceInstanceId((int)dbMap.get("service_instance_id")); - indicator.setSummation((long)dbMap.get("summation")); - indicator.setCount((int)dbMap.get("count")); - indicator.setValue((long)dbMap.get("value")); - indicator.setTimeBucket((long)dbMap.get("time_bucket")); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceId(((Number)dbMap.get("service_id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setSummation(((Number)dbMap.get("summation")).longValue()); + indicator.setCount(((Number)dbMap.get("count")).intValue()); + indicator.setValue(((Number)dbMap.get("value")).longValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); return indicator; } } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointDispatcher.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointDispatcher.java index 4f54a6b5e..73436254f 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointDispatcher.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointDispatcher.java @@ -29,7 +29,6 @@ import org.apache.skywalking.oap.server.core.source.Endpoint; */ public class EndpointDispatcher implements SourceDispatcher { - @Override public void dispatch(Endpoint source) { doEndpointAvg(source); doEndpointPercent(source); @@ -45,6 +44,7 @@ public class EndpointDispatcher implements SourceDispatcher { indicator.combine(source.getLatency(), 1); IndicatorProcess.INSTANCE.in(indicator); } + private void doEndpointPercent(Endpoint source) { EndpointPercentIndicator indicator = new EndpointPercentIndicator(); @@ -55,4 +55,5 @@ public class EndpointDispatcher implements SourceDispatcher { indicator.combine(new org.apache.skywalking.oap.server.core.analysis.indicator.expression.BooleanBinaryMatch(), source.isStatus(), true); IndicatorProcess.INSTANCE.in(indicator); } + } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointPercentIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointPercentIndicator.java index 72a092acf..e581434ab 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointPercentIndicator.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/endpoint/EndpointPercentIndicator.java @@ -20,12 +20,13 @@ package org.apache.skywalking.oap.server.core.analysis.generated.endpoint; import java.util.*; import lombok.*; -import org.apache.skywalking.oap.server.core.analysis.indicator.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.PercentIndicator; import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; -import org.apache.skywalking.oap.server.core.storage.annotation.*; import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; /** * This class is auto generated. Please don't change this class manually. @@ -42,7 +43,9 @@ public class EndpointPercentIndicator extends PercentIndicator { @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; @Override public String id() { - return String.valueOf(id); + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; } @Override public int hashCode() { @@ -52,7 +55,6 @@ public class EndpointPercentIndicator extends PercentIndicator { return result; } - @Override public boolean equals(Object obj) { if (this == obj) return true; @@ -70,7 +72,6 @@ public class EndpointPercentIndicator extends PercentIndicator { return true; } - @Override public RemoteData.Builder serialize() { RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); @@ -116,13 +117,13 @@ public class EndpointPercentIndicator extends PercentIndicator { @Override public EndpointPercentIndicator map2Data(Map dbMap) { EndpointPercentIndicator indicator = new EndpointPercentIndicator(); - indicator.setId((int)dbMap.get("id")); - indicator.setServiceId((int)dbMap.get("service_id")); - indicator.setServiceInstanceId((int)dbMap.get("service_instance_id")); - indicator.setTotal((long)dbMap.get("total")); - indicator.setPercentage((int)dbMap.get("percentage")); - indicator.setMatch((long)dbMap.get("match")); - indicator.setTimeBucket((long)dbMap.get("time_bucket")); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceId(((Number)dbMap.get("service_id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setTotal(((Number)dbMap.get("total")).longValue()); + indicator.setPercentage(((Number)dbMap.get("percentage")).intValue()); + indicator.setMatch(((Number)dbMap.get("match")).longValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); return indicator; } } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/InstanceJvmCpuIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/InstanceJvmCpuIndicator.java new file mode 100644 index 000000000..cc193650f --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/InstanceJvmCpuIndicator.java @@ -0,0 +1,125 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmcpu; + +import java.util.*; +import lombok.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.DoubleAvgIndicator; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; +import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; +import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; +import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +@IndicatorType +@StreamData +@StorageEntity(name = "instance_jvm_cpu", builder = InstanceJvmCpuIndicator.Builder.class) +public class InstanceJvmCpuIndicator extends DoubleAvgIndicator { + + @Setter @Getter @Column(columnName = "id") private int id; + @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; + + @Override public String id() { + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; + } + + @Override public int hashCode() { + int result = 17; + result = 31 * result + id; + result = 31 * result + (int)getTimeBucket(); + return result; + } + + @Override public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + + InstanceJvmCpuIndicator indicator = (InstanceJvmCpuIndicator)obj; + if (id != indicator.id) + return false; + if (getTimeBucket() != indicator.getTimeBucket()) + return false; + + return true; + } + + @Override public RemoteData.Builder serialize() { + RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); + + remoteBuilder.setDataLongs(0, getTimeBucket()); + + remoteBuilder.setDataDoubles(0, getSummation()); + remoteBuilder.setDataDoubles(1, getValue()); + + remoteBuilder.setDataIntegers(0, getId()); + remoteBuilder.setDataIntegers(1, getServiceInstanceId()); + remoteBuilder.setDataIntegers(2, getCount()); + + return remoteBuilder; + } + + @Override public void deserialize(RemoteData remoteData) { + + setTimeBucket(remoteData.getDataLongs(0)); + + setSummation(remoteData.getDataDoubles(0)); + setValue(remoteData.getDataDoubles(1)); + + setId(remoteData.getDataIntegers(0)); + setServiceInstanceId(remoteData.getDataIntegers(1)); + setCount(remoteData.getDataIntegers(2)); + } + + public static class Builder implements StorageBuilder { + + @Override public Map data2Map(InstanceJvmCpuIndicator storageData) { + Map map = new HashMap<>(); + map.put("id", storageData.getId()); + map.put("service_instance_id", storageData.getServiceInstanceId()); + map.put("summation", storageData.getSummation()); + map.put("count", storageData.getCount()); + map.put("value", storageData.getValue()); + map.put("time_bucket", storageData.getTimeBucket()); + return map; + } + + @Override public InstanceJvmCpuIndicator map2Data(Map dbMap) { + InstanceJvmCpuIndicator indicator = new InstanceJvmCpuIndicator(); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setSummation(((Number)dbMap.get("summation")).doubleValue()); + indicator.setCount(((Number)dbMap.get("count")).intValue()); + indicator.setValue(((Number)dbMap.get("value")).doubleValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); + return indicator; + } + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/ServiceInstanceJVMCPUDispatcher.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/ServiceInstanceJVMCPUDispatcher.java new file mode 100644 index 000000000..48df5b419 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmcpu/ServiceInstanceJVMCPUDispatcher.java @@ -0,0 +1,45 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmcpu; + +import org.apache.skywalking.oap.server.core.analysis.SourceDispatcher; +import org.apache.skywalking.oap.server.core.analysis.worker.IndicatorProcess; +import org.apache.skywalking.oap.server.core.source.ServiceInstanceJVMCPU; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +public class ServiceInstanceJVMCPUDispatcher implements SourceDispatcher { + + @Override public void dispatch(ServiceInstanceJVMCPU source) { + doInstanceJvmCpu(source); + } + + private void doInstanceJvmCpu(ServiceInstanceJVMCPU source) { + InstanceJvmCpuIndicator indicator = new InstanceJvmCpuIndicator(); + + indicator.setTimeBucket(source.getTimeBucket()); + indicator.setId(source.getId()); + indicator.setServiceInstanceId(source.getServiceInstanceId()); + indicator.combine(source.getUsePercent(), 1); + IndicatorProcess.INSTANCE.in(indicator); + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/InstanceJvmGcTimeIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/InstanceJvmGcTimeIndicator.java new file mode 100644 index 000000000..d2c7147ac --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/InstanceJvmGcTimeIndicator.java @@ -0,0 +1,125 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmgc; + +import java.util.*; +import lombok.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.LongAvgIndicator; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; +import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; +import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; +import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +@IndicatorType +@StreamData +@StorageEntity(name = "instance_jvm_gc_time", builder = InstanceJvmGcTimeIndicator.Builder.class) +public class InstanceJvmGcTimeIndicator extends LongAvgIndicator { + + @Setter @Getter @Column(columnName = "id") private int id; + @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; + + @Override public String id() { + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; + } + + @Override public int hashCode() { + int result = 17; + result = 31 * result + id; + result = 31 * result + (int)getTimeBucket(); + return result; + } + + @Override public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + + InstanceJvmGcTimeIndicator indicator = (InstanceJvmGcTimeIndicator)obj; + if (id != indicator.id) + return false; + if (getTimeBucket() != indicator.getTimeBucket()) + return false; + + return true; + } + + @Override public RemoteData.Builder serialize() { + RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); + + remoteBuilder.setDataLongs(0, getSummation()); + remoteBuilder.setDataLongs(1, getValue()); + remoteBuilder.setDataLongs(2, getTimeBucket()); + + + remoteBuilder.setDataIntegers(0, getId()); + remoteBuilder.setDataIntegers(1, getServiceInstanceId()); + remoteBuilder.setDataIntegers(2, getCount()); + + return remoteBuilder; + } + + @Override public void deserialize(RemoteData remoteData) { + + setSummation(remoteData.getDataLongs(0)); + setValue(remoteData.getDataLongs(1)); + setTimeBucket(remoteData.getDataLongs(2)); + + + setId(remoteData.getDataIntegers(0)); + setServiceInstanceId(remoteData.getDataIntegers(1)); + setCount(remoteData.getDataIntegers(2)); + } + + public static class Builder implements StorageBuilder { + + @Override public Map data2Map(InstanceJvmGcTimeIndicator storageData) { + Map map = new HashMap<>(); + map.put("id", storageData.getId()); + map.put("service_instance_id", storageData.getServiceInstanceId()); + map.put("summation", storageData.getSummation()); + map.put("count", storageData.getCount()); + map.put("value", storageData.getValue()); + map.put("time_bucket", storageData.getTimeBucket()); + return map; + } + + @Override public InstanceJvmGcTimeIndicator map2Data(Map dbMap) { + InstanceJvmGcTimeIndicator indicator = new InstanceJvmGcTimeIndicator(); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setSummation(((Number)dbMap.get("summation")).longValue()); + indicator.setCount(((Number)dbMap.get("count")).intValue()); + indicator.setValue(((Number)dbMap.get("value")).longValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); + return indicator; + } + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/ServiceInstanceJVMGCDispatcher.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/ServiceInstanceJVMGCDispatcher.java new file mode 100644 index 000000000..c634b96b2 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmgc/ServiceInstanceJVMGCDispatcher.java @@ -0,0 +1,45 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmgc; + +import org.apache.skywalking.oap.server.core.analysis.SourceDispatcher; +import org.apache.skywalking.oap.server.core.analysis.worker.IndicatorProcess; +import org.apache.skywalking.oap.server.core.source.ServiceInstanceJVMGC; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +public class ServiceInstanceJVMGCDispatcher implements SourceDispatcher { + + @Override public void dispatch(ServiceInstanceJVMGC source) { + doInstanceJvmGcTime(source); + } + + private void doInstanceJvmGcTime(ServiceInstanceJVMGC source) { + InstanceJvmGcTimeIndicator indicator = new InstanceJvmGcTimeIndicator(); + + indicator.setTimeBucket(source.getTimeBucket()); + indicator.setId(source.getId()); + indicator.setServiceInstanceId(source.getServiceInstanceId()); + indicator.combine(source.getTime(), 1); + IndicatorProcess.INSTANCE.in(indicator); + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/InstanceJvmMemoryMaxIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/InstanceJvmMemoryMaxIndicator.java new file mode 100644 index 000000000..c3e53cf29 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/InstanceJvmMemoryMaxIndicator.java @@ -0,0 +1,125 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemory; + +import java.util.*; +import lombok.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.LongAvgIndicator; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; +import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; +import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; +import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +@IndicatorType +@StreamData +@StorageEntity(name = "instance_jvm_memory_max", builder = InstanceJvmMemoryMaxIndicator.Builder.class) +public class InstanceJvmMemoryMaxIndicator extends LongAvgIndicator { + + @Setter @Getter @Column(columnName = "id") private int id; + @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; + + @Override public String id() { + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; + } + + @Override public int hashCode() { + int result = 17; + result = 31 * result + id; + result = 31 * result + (int)getTimeBucket(); + return result; + } + + @Override public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + + InstanceJvmMemoryMaxIndicator indicator = (InstanceJvmMemoryMaxIndicator)obj; + if (id != indicator.id) + return false; + if (getTimeBucket() != indicator.getTimeBucket()) + return false; + + return true; + } + + @Override public RemoteData.Builder serialize() { + RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); + + remoteBuilder.setDataLongs(0, getSummation()); + remoteBuilder.setDataLongs(1, getValue()); + remoteBuilder.setDataLongs(2, getTimeBucket()); + + + remoteBuilder.setDataIntegers(0, getId()); + remoteBuilder.setDataIntegers(1, getServiceInstanceId()); + remoteBuilder.setDataIntegers(2, getCount()); + + return remoteBuilder; + } + + @Override public void deserialize(RemoteData remoteData) { + + setSummation(remoteData.getDataLongs(0)); + setValue(remoteData.getDataLongs(1)); + setTimeBucket(remoteData.getDataLongs(2)); + + + setId(remoteData.getDataIntegers(0)); + setServiceInstanceId(remoteData.getDataIntegers(1)); + setCount(remoteData.getDataIntegers(2)); + } + + public static class Builder implements StorageBuilder { + + @Override public Map data2Map(InstanceJvmMemoryMaxIndicator storageData) { + Map map = new HashMap<>(); + map.put("id", storageData.getId()); + map.put("service_instance_id", storageData.getServiceInstanceId()); + map.put("summation", storageData.getSummation()); + map.put("count", storageData.getCount()); + map.put("value", storageData.getValue()); + map.put("time_bucket", storageData.getTimeBucket()); + return map; + } + + @Override public InstanceJvmMemoryMaxIndicator map2Data(Map dbMap) { + InstanceJvmMemoryMaxIndicator indicator = new InstanceJvmMemoryMaxIndicator(); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setSummation(((Number)dbMap.get("summation")).longValue()); + indicator.setCount(((Number)dbMap.get("count")).intValue()); + indicator.setValue(((Number)dbMap.get("value")).longValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); + return indicator; + } + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/ServiceInstanceJVMMemoryDispatcher.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/ServiceInstanceJVMMemoryDispatcher.java new file mode 100644 index 000000000..ddcc5e866 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemory/ServiceInstanceJVMMemoryDispatcher.java @@ -0,0 +1,45 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemory; + +import org.apache.skywalking.oap.server.core.analysis.SourceDispatcher; +import org.apache.skywalking.oap.server.core.analysis.worker.IndicatorProcess; +import org.apache.skywalking.oap.server.core.source.ServiceInstanceJVMMemory; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +public class ServiceInstanceJVMMemoryDispatcher implements SourceDispatcher { + + @Override public void dispatch(ServiceInstanceJVMMemory source) { + doInstanceJvmMemoryMax(source); + } + + private void doInstanceJvmMemoryMax(ServiceInstanceJVMMemory source) { + InstanceJvmMemoryMaxIndicator indicator = new InstanceJvmMemoryMaxIndicator(); + + indicator.setTimeBucket(source.getTimeBucket()); + indicator.setId(source.getId()); + indicator.setServiceInstanceId(source.getServiceInstanceId()); + indicator.combine(source.getMax(), 1); + IndicatorProcess.INSTANCE.in(indicator); + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/InstanceJvmMemoryPoolMaxIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/InstanceJvmMemoryPoolMaxIndicator.java new file mode 100644 index 000000000..42f1a75ff --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/InstanceJvmMemoryPoolMaxIndicator.java @@ -0,0 +1,125 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemorypool; + +import java.util.*; +import lombok.*; +import org.apache.skywalking.oap.server.core.Const; +import org.apache.skywalking.oap.server.core.analysis.indicator.LongAvgIndicator; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorType; +import org.apache.skywalking.oap.server.core.remote.annotation.StreamData; +import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; +import org.apache.skywalking.oap.server.core.storage.StorageBuilder; +import org.apache.skywalking.oap.server.core.storage.annotation.*; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +@IndicatorType +@StreamData +@StorageEntity(name = "instance_jvm_memory_pool_max", builder = InstanceJvmMemoryPoolMaxIndicator.Builder.class) +public class InstanceJvmMemoryPoolMaxIndicator extends LongAvgIndicator { + + @Setter @Getter @Column(columnName = "id") private int id; + @Setter @Getter @Column(columnName = "service_instance_id") private int serviceInstanceId; + + @Override public String id() { + String splitJointId = String.valueOf(getTimeBucket()); + splitJointId += Const.ID_SPLIT + String.valueOf(id); + return splitJointId; + } + + @Override public int hashCode() { + int result = 17; + result = 31 * result + id; + result = 31 * result + (int)getTimeBucket(); + return result; + } + + @Override public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + + InstanceJvmMemoryPoolMaxIndicator indicator = (InstanceJvmMemoryPoolMaxIndicator)obj; + if (id != indicator.id) + return false; + if (getTimeBucket() != indicator.getTimeBucket()) + return false; + + return true; + } + + @Override public RemoteData.Builder serialize() { + RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); + + remoteBuilder.setDataLongs(0, getSummation()); + remoteBuilder.setDataLongs(1, getValue()); + remoteBuilder.setDataLongs(2, getTimeBucket()); + + + remoteBuilder.setDataIntegers(0, getId()); + remoteBuilder.setDataIntegers(1, getServiceInstanceId()); + remoteBuilder.setDataIntegers(2, getCount()); + + return remoteBuilder; + } + + @Override public void deserialize(RemoteData remoteData) { + + setSummation(remoteData.getDataLongs(0)); + setValue(remoteData.getDataLongs(1)); + setTimeBucket(remoteData.getDataLongs(2)); + + + setId(remoteData.getDataIntegers(0)); + setServiceInstanceId(remoteData.getDataIntegers(1)); + setCount(remoteData.getDataIntegers(2)); + } + + public static class Builder implements StorageBuilder { + + @Override public Map data2Map(InstanceJvmMemoryPoolMaxIndicator storageData) { + Map map = new HashMap<>(); + map.put("id", storageData.getId()); + map.put("service_instance_id", storageData.getServiceInstanceId()); + map.put("summation", storageData.getSummation()); + map.put("count", storageData.getCount()); + map.put("value", storageData.getValue()); + map.put("time_bucket", storageData.getTimeBucket()); + return map; + } + + @Override public InstanceJvmMemoryPoolMaxIndicator map2Data(Map dbMap) { + InstanceJvmMemoryPoolMaxIndicator indicator = new InstanceJvmMemoryPoolMaxIndicator(); + indicator.setId(((Number)dbMap.get("id")).intValue()); + indicator.setServiceInstanceId(((Number)dbMap.get("service_instance_id")).intValue()); + indicator.setSummation(((Number)dbMap.get("summation")).longValue()); + indicator.setCount(((Number)dbMap.get("count")).intValue()); + indicator.setValue(((Number)dbMap.get("value")).longValue()); + indicator.setTimeBucket(((Number)dbMap.get("time_bucket")).longValue()); + return indicator; + } + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/ServiceInstanceJVMMemoryPoolDispatcher.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/ServiceInstanceJVMMemoryPoolDispatcher.java new file mode 100644 index 000000000..ad9d1e69f --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/serviceinstancejvmmemorypool/ServiceInstanceJVMMemoryPoolDispatcher.java @@ -0,0 +1,45 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.generated.serviceinstancejvmmemorypool; + +import org.apache.skywalking.oap.server.core.analysis.SourceDispatcher; +import org.apache.skywalking.oap.server.core.analysis.worker.IndicatorProcess; +import org.apache.skywalking.oap.server.core.source.ServiceInstanceJVMMemoryPool; + +/** + * This class is auto generated. Please don't change this class manually. + * + * @author Observability Analysis Language code generator + */ +public class ServiceInstanceJVMMemoryPoolDispatcher implements SourceDispatcher { + + @Override public void dispatch(ServiceInstanceJVMMemoryPool source) { + doInstanceJvmMemoryPoolMax(source); + } + + private void doInstanceJvmMemoryPoolMax(ServiceInstanceJVMMemoryPool source) { + InstanceJvmMemoryPoolMaxIndicator indicator = new InstanceJvmMemoryPoolMaxIndicator(); + + indicator.setTimeBucket(source.getTimeBucket()); + indicator.setId(source.getId()); + indicator.setServiceInstanceId(source.getServiceInstanceId()); + indicator.combine(source.getMax(), 1); + IndicatorProcess.INSTANCE.in(indicator); + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/DoubleAvgIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/DoubleAvgIndicator.java new file mode 100644 index 000000000..895fa871a --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/DoubleAvgIndicator.java @@ -0,0 +1,53 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.analysis.indicator; + +import lombok.*; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.*; +import org.apache.skywalking.oap.server.core.storage.annotation.Column; + +/** + * @author peng-yongsheng + */ +@IndicatorOperator +public abstract class DoubleAvgIndicator extends Indicator { + + protected static final String SUMMATION = "summation"; + protected static final String COUNT = "count"; + protected static final String VALUE = "value"; + + @Getter @Setter @Column(columnName = SUMMATION) private double summation; + @Getter @Setter @Column(columnName = COUNT) private int count; + @Getter @Setter @Column(columnName = VALUE) private double value; + + @Entrance + public final void combine(@SourceFrom double summation, @ConstOne int count) { + this.summation += summation; + this.count += count; + } + + @Override public final void combine(Indicator indicator) { + DoubleAvgIndicator avgIndicator = (DoubleAvgIndicator)indicator; + combine(avgIndicator.summation, avgIndicator.count); + } + + @Override public final void calculate() { + this.value = this.summation / this.count; + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/Indicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/Indicator.java index fe29ed6ee..933ac592d 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/Indicator.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/Indicator.java @@ -35,4 +35,6 @@ public abstract class Indicator extends StreamData implements StorageData { public abstract String id(); public abstract void combine(Indicator indicator); + + public abstract void calculate(); } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/AvgIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/LongAvgIndicator.java similarity index 88% rename from oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/AvgIndicator.java rename to oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/LongAvgIndicator.java index 41f24c85a..1649af3ac 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/AvgIndicator.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/LongAvgIndicator.java @@ -26,7 +26,7 @@ import org.apache.skywalking.oap.server.core.storage.annotation.Column; * @author peng-yongsheng */ @IndicatorOperator -public abstract class AvgIndicator extends Indicator { +public abstract class LongAvgIndicator extends Indicator { protected static final String SUMMATION = "summation"; protected static final String COUNT = "count"; @@ -43,7 +43,11 @@ public abstract class AvgIndicator extends Indicator { } @Override public final void combine(Indicator indicator) { - AvgIndicator avgIndicator = (AvgIndicator)indicator; + LongAvgIndicator avgIndicator = (LongAvgIndicator)indicator; combine(avgIndicator.summation, avgIndicator.count); } + + @Override public final void calculate() { + this.value = this.summation / this.count; + } } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/PercentIndicator.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/PercentIndicator.java index ab590e817..b5b4551bd 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/PercentIndicator.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/PercentIndicator.java @@ -18,13 +18,8 @@ package org.apache.skywalking.oap.server.core.analysis.indicator; -import lombok.Getter; -import lombok.Setter; -import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.Entrance; -import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.Expression; -import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.ExpressionArg0; -import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.ExpressionArg1; -import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.IndicatorOperator; +import lombok.*; +import org.apache.skywalking.oap.server.core.analysis.indicator.annotation.*; import org.apache.skywalking.oap.server.core.analysis.indicator.expression.BooleanBinaryMatch; import org.apache.skywalking.oap.server.core.storage.annotation.Column; @@ -56,4 +51,8 @@ public abstract class PercentIndicator extends Indicator { total += ((PercentIndicator)indicator).total; match += ((PercentIndicator)indicator).match; } + + @Override public void calculate() { + percentage = (int)(match / total); + } } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/DetectPoint.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/DetectPoint.java new file mode 100644 index 000000000..bdc60eaf3 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/DetectPoint.java @@ -0,0 +1,26 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +/** + * @author peng-yongsheng + */ +public enum DetectPoint { + CLIENT, SERVER, PROXY +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Endpoint.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Endpoint.java index e1f68fea9..c4063b904 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Endpoint.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Endpoint.java @@ -19,7 +19,6 @@ package org.apache.skywalking.oap.server.core.source; import lombok.*; -import org.apache.skywalking.apm.network.language.agent.SpanLayer; import org.apache.skywalking.oap.server.core.source.annotation.SourceType; /** @@ -40,5 +39,5 @@ public class Endpoint extends Source { @Getter @Setter private int latency; @Getter @Setter private boolean status; @Getter @Setter private int responseCode; - @Getter @Setter private SpanLayer type; + @Getter @Setter private RequestType type; } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/EndpointRelation.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/EndpointRelation.java index 896cf7c32..8c0ed3bd6 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/EndpointRelation.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/EndpointRelation.java @@ -19,7 +19,6 @@ package org.apache.skywalking.oap.server.core.source; import lombok.*; -import org.apache.skywalking.apm.network.language.agent.*; /** * @author peng-yongsheng @@ -37,7 +36,7 @@ public class EndpointRelation extends Source { @Getter @Setter private int rpcLatency; @Getter @Setter private boolean status; @Getter @Setter private int responseCode; - @Getter @Setter private SpanLayer type; - @Getter @Setter private SpanType detectPoint; + @Getter @Setter private RequestType type; + @Getter @Setter private DetectPoint detectPoint; } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/GCPhrase.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/GCPhrase.java new file mode 100644 index 000000000..1c06ee3f8 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/GCPhrase.java @@ -0,0 +1,26 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +/** + * @author peng-yongsheng + */ +public enum GCPhrase { + NEW, OLD +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/MemoryPoolType.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/MemoryPoolType.java new file mode 100644 index 000000000..7811715c8 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/MemoryPoolType.java @@ -0,0 +1,26 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +/** + * @author peng-yongsheng + */ +public enum MemoryPoolType { + CODE_CACHE_USAGE, NEWGEN_USAGE, OLDGEN_USAGE, SURVIVOR_USAGE, PERMGEN_USAGE, METASPACE_USAGE +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/RequestType.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/RequestType.java new file mode 100644 index 000000000..dfe2c7a3d --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/RequestType.java @@ -0,0 +1,26 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +/** + * @author peng-yongsheng + */ +public enum RequestType { + DATABASE, HTTP, RPC, gRPC +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Scope.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Scope.java index e6c5e8119..43c1ef30e 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Scope.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Scope.java @@ -22,5 +22,6 @@ package org.apache.skywalking.oap.server.core.source; * @author peng-yongsheng */ public enum Scope { - All, Service, ServiceInstance, Endpoint, ServiceRelation, ServiceInstanceRelation, EndpointRelation, NetworkAddress + All, Service, ServiceInstance, Endpoint, ServiceRelation, ServiceInstanceRelation, EndpointRelation, NetworkAddress, + ServiceInstanceJVMCPU, ServiceInstanceJVMMemory, ServiceInstanceJVMMemoryPool, ServiceInstanceJVMGC } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Service.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Service.java index 15f28e3b8..c1a5719b8 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Service.java +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/Service.java @@ -18,14 +18,24 @@ package org.apache.skywalking.oap.server.core.source; +import lombok.*; import org.apache.skywalking.oap.server.core.source.annotation.SourceType; /** - * @author wusheng + * @author wusheng, peng-yongsheng */ @SourceType public class Service extends Source { @Override public Scope scope() { return Scope.Service; } + + @Getter @Setter private int id; + @Getter @Setter private String name; + @Getter @Setter private String serviceInstanceName; + @Getter @Setter private String endpointName; + @Getter @Setter private int latency; + @Getter @Setter private boolean status; + @Getter @Setter private int responseCode; + @Getter @Setter private RequestType type; } diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMCPU.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMCPU.java new file mode 100644 index 000000000..6d3397cf7 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMCPU.java @@ -0,0 +1,38 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +import lombok.*; +import org.apache.skywalking.oap.server.core.source.annotation.SourceType; + +/** + * @author peng-yongsheng + */ +@SourceType +public class ServiceInstanceJVMCPU extends Source { + @Override public Scope scope() { + return Scope.ServiceInstanceJVMCPU; + } + + @Getter @Setter private int id; + @Getter @Setter private String name; + @Getter @Setter private String serviceName; + @Getter @Setter private int serviceInstanceId; + @Getter @Setter private double usePercent; +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMGC.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMGC.java new file mode 100644 index 000000000..4c52e528d --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMGC.java @@ -0,0 +1,40 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +import lombok.*; +import org.apache.skywalking.oap.server.core.source.annotation.SourceType; + +/** + * @author peng-yongsheng + */ +@SourceType +public class ServiceInstanceJVMGC extends Source { + @Override public Scope scope() { + return Scope.ServiceInstanceJVMGC; + } + + @Getter @Setter private int id; + @Getter @Setter private String name; + @Getter @Setter private String serviceName; + @Getter @Setter private int serviceInstanceId; + @Getter @Setter private GCPhrase phrase; + @Getter @Setter private long time; + @Getter @Setter private long count; +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemory.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemory.java new file mode 100644 index 000000000..b66c9b3e2 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemory.java @@ -0,0 +1,40 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +import lombok.*; + +/** + * @author peng-yongsheng + */ +public class ServiceInstanceJVMMemory extends Source { + @Override public Scope scope() { + return Scope.ServiceInstanceJVMMemory; + } + + @Getter @Setter private int id; + @Getter @Setter private String name; + @Getter @Setter private String serviceName; + @Getter @Setter private int serviceInstanceId; + @Getter @Setter private boolean isHeap; + @Getter @Setter private long init; + @Getter @Setter private long max; + @Getter @Setter private long used; + @Getter @Setter private long committed; +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemoryPool.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemoryPool.java new file mode 100644 index 000000000..ea5a09cb1 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/source/ServiceInstanceJVMMemoryPool.java @@ -0,0 +1,40 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.core.source; + +import lombok.*; + +/** + * @author peng-yongsheng + */ +public class ServiceInstanceJVMMemoryPool extends Source { + @Override public Scope scope() { + return Scope.ServiceInstanceJVMMemoryPool; + } + + @Getter @Setter private int id; + @Getter @Setter private String name; + @Getter @Setter private String serviceName; + @Getter @Setter private int serviceInstanceId; + @Getter @Setter private MemoryPoolType poolType; + @Getter @Setter private long init; + @Getter @Setter private long max; + @Getter @Setter private long used; + @Getter @Setter private long committed; +} diff --git a/oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestAvgIndicator.java b/oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestLongAvgIndicator.java similarity index 94% rename from oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestAvgIndicator.java rename to oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestLongAvgIndicator.java index 757215de2..737badfa5 100644 --- a/oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestAvgIndicator.java +++ b/oap-server/server-core/src/test/java/org/apache/skywalking/oap/server/core/analysis/indicator/define/TestLongAvgIndicator.java @@ -19,13 +19,13 @@ package org.apache.skywalking.oap.server.core.analysis.indicator.define; import lombok.*; -import org.apache.skywalking.oap.server.core.analysis.indicator.AvgIndicator; +import org.apache.skywalking.oap.server.core.analysis.indicator.LongAvgIndicator; import org.apache.skywalking.oap.server.core.remote.grpc.proto.RemoteData; /** * @author peng-yongsheng */ -public class TestAvgIndicator extends AvgIndicator { +public class TestLongAvgIndicator extends LongAvgIndicator { @Setter @Getter private int id; diff --git a/oap-server/server-library/library-util/src/main/java/org/apache/skywalking/oap/server/library/util/TimeBucketUtils.java b/oap-server/server-library/library-util/src/main/java/org/apache/skywalking/oap/server/library/util/TimeBucketUtils.java new file mode 100644 index 000000000..078c6a32d --- /dev/null +++ b/oap-server/server-library/library-util/src/main/java/org/apache/skywalking/oap/server/library/util/TimeBucketUtils.java @@ -0,0 +1,75 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.library.util; + +import java.text.*; +import java.util.*; + +/** + * @author peng-yongsheng + */ +public enum TimeBucketUtils { + INSTANCE; + + public long getMinuteTimeBucket(long time) { + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(time); + + long year = calendar.get(Calendar.YEAR); + long month = calendar.get(Calendar.MONTH) + 1; + long day = calendar.get(Calendar.DAY_OF_MONTH); + long hour = calendar.get(Calendar.HOUR_OF_DAY); + long minute = calendar.get(Calendar.MINUTE); + + return year * 100000000 + month * 1000000 + day * 10000 + hour * 100 + minute; + } + + public long getSecondTimeBucket(long time) { + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(time); + + long year = calendar.get(Calendar.YEAR); + long month = calendar.get(Calendar.MONTH) + 1; + long day = calendar.get(Calendar.DAY_OF_MONTH); + long hour = calendar.get(Calendar.HOUR_OF_DAY); + long minute = calendar.get(Calendar.MINUTE); + long second = calendar.get(Calendar.SECOND); + + return year * 10000000000L + month * 100000000 + day * 1000000 + hour * 10000 + minute * 100 + second; + } + + public String formatMinuteTimeBucket(long minuteTimeBucket) throws ParseException { + SimpleDateFormat minuteDateFormat = new SimpleDateFormat("yyyyMMddHHmm"); + Date date = minuteDateFormat.parse(String.valueOf(minuteTimeBucket)); + SimpleDateFormat parsedMinuteDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm"); + return parsedMinuteDateFormat.format(date); + } + + public long minuteToHour(long minuteBucket) { + return minuteBucket / 100; + } + + public long minuteToDay(long minuteBucket) { + return minuteBucket / 100 / 100; + } + + public long minuteToMonth(long minuteBucket) { + return minuteBucket / 100 / 100 / 100; + } +} diff --git a/oap-server/server-receiver-plugin/pom.xml b/oap-server/server-receiver-plugin/pom.xml index 8a9131bdc..96faaa9a5 100644 --- a/oap-server/server-receiver-plugin/pom.xml +++ b/oap-server/server-receiver-plugin/pom.xml @@ -35,6 +35,7 @@ skywalking-mesh-receiver-plugin skywalking-istio-telemetry-receiver-plugin skywalking-register-receiver-plugin + skywalking-jvm-receiver-plugin @@ -43,6 +44,11 @@ server-core ${project.version} + + org.apache.skywalking + apm-network + ${project.version} + org.apache.skywalking library-module diff --git a/oap-server/server-receiver-plugin/skywalking-istio-telemetry-receiver-plugin/pom.xml b/oap-server/server-receiver-plugin/skywalking-istio-telemetry-receiver-plugin/pom.xml index 1152aa51b..1baefe53f 100644 --- a/oap-server/server-receiver-plugin/skywalking-istio-telemetry-receiver-plugin/pom.xml +++ b/oap-server/server-receiver-plugin/skywalking-istio-telemetry-receiver-plugin/pom.xml @@ -30,14 +30,6 @@ skywalking-istio-telemetry-receiver-plugin jar - - - org.apache.skywalking - server-core - ${project.version} - - - diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/pom.xml b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/pom.xml new file mode 100644 index 000000000..05381520a --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/pom.xml @@ -0,0 +1,32 @@ + + + + + + server-receiver-plugin + org.apache.skywalking + 6.0.0-alpha-SNAPSHOT + + 4.0.0 + + skywalking-jvm-receiver-plugin + jar + \ No newline at end of file diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/service/ServiceDispatcher.java b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/module/JVMModule.java similarity index 63% rename from oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/service/ServiceDispatcher.java rename to oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/module/JVMModule.java index 7452ccd2c..16c7211dc 100644 --- a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/generated/service/ServiceDispatcher.java +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/module/JVMModule.java @@ -16,18 +16,20 @@ * */ -package org.apache.skywalking.oap.server.core.analysis.generated.service; +package org.apache.skywalking.oap.server.receiver.jvm.module; -import org.apache.skywalking.oap.server.core.analysis.SourceDispatcher; -import org.apache.skywalking.oap.server.core.source.Service; +import org.apache.skywalking.oap.server.library.module.ModuleDefine; /** - * This class is auto generated. Please don't change this class manually. - * - * @author Observability Analysis Language code generator + * @author peng-yongsheng */ -public class ServiceDispatcher implements SourceDispatcher { - @Override public void dispatch(Service source) { +public class JVMModule extends ModuleDefine { + + @Override public String name() { + return "receiver-jvm"; } + @Override public Class[] services() { + return new Class[0]; + } } diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/JVMModuleProvider.java b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/JVMModuleProvider.java new file mode 100644 index 000000000..dfb762690 --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/JVMModuleProvider.java @@ -0,0 +1,59 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.receiver.jvm.provider; + +import org.apache.skywalking.oap.server.core.CoreModule; +import org.apache.skywalking.oap.server.core.server.GRPCHandlerRegister; +import org.apache.skywalking.oap.server.library.module.*; +import org.apache.skywalking.oap.server.receiver.jvm.module.JVMModule; +import org.apache.skywalking.oap.server.receiver.jvm.provider.handler.JVMMetricsServiceHandler; + +/** + * @author peng-yongsheng + */ +public class JVMModuleProvider extends ModuleProvider { + + @Override public String name() { + return "default"; + } + + @Override public Class module() { + return JVMModule.class; + } + + @Override public ModuleConfig createConfigBeanIfAbsent() { + return null; + } + + @Override public void prepare() { + } + + @Override public void start() { + GRPCHandlerRegister grpcHandlerRegister = getManager().find(CoreModule.NAME).getService(GRPCHandlerRegister.class); + grpcHandlerRegister.addHandler(new JVMMetricsServiceHandler(getManager())); + } + + @Override public void notifyAfterCompleted() { + + } + + @Override public String[] requiredModules() { + return new String[] {CoreModule.NAME}; + } +} diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandler.java b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandler.java new file mode 100644 index 000000000..ede98bf76 --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandler.java @@ -0,0 +1,152 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.receiver.jvm.provider.handler; + +import io.grpc.stub.StreamObserver; +import java.util.List; +import org.apache.skywalking.apm.network.language.agent.*; +import org.apache.skywalking.oap.server.core.*; +import org.apache.skywalking.oap.server.core.source.GCPhrase; +import org.apache.skywalking.oap.server.core.source.*; +import org.apache.skywalking.oap.server.library.module.ModuleManager; +import org.apache.skywalking.oap.server.library.server.grpc.GRPCHandler; +import org.apache.skywalking.oap.server.library.util.TimeBucketUtils; +import org.slf4j.*; + +/** + * @author peng-yongsheng + */ +public class JVMMetricsServiceHandler extends JVMMetricsServiceGrpc.JVMMetricsServiceImplBase implements GRPCHandler { + + private static final Logger logger = LoggerFactory.getLogger(JVMMetricsServiceHandler.class); + + private final SourceReceiver sourceReceiver; + + public JVMMetricsServiceHandler(ModuleManager moduleManager) { + this.sourceReceiver = moduleManager.find(CoreModule.NAME).getService(SourceReceiver.class); + } + + @Override public void collect(JVMMetrics request, StreamObserver responseObserver) { + int serviceInstanceId = request.getApplicationInstanceId(); + + if (logger.isDebugEnabled()) { + logger.debug("receive the jvm metric from application instance, id: {}", serviceInstanceId); + } + + request.getMetricsList().forEach(metric -> { + long minuteTimeBucket = TimeBucketUtils.INSTANCE.getMinuteTimeBucket(metric.getTime()); + sendToCpuMetricProcess(serviceInstanceId, minuteTimeBucket, metric.getCpu()); + sendToMemoryMetricProcess(serviceInstanceId, minuteTimeBucket, metric.getMemoryList()); + sendToMemoryPoolMetricProcess(serviceInstanceId, minuteTimeBucket, metric.getMemoryPoolList()); + sendToGCMetricProcess(serviceInstanceId, minuteTimeBucket, metric.getGcList()); + sendToInstanceHeartBeatProcess(serviceInstanceId, metric.getTime()); + }); + + responseObserver.onNext(Downstream.newBuilder().build()); + responseObserver.onCompleted(); + } + + private void sendToCpuMetricProcess(int serviceInstanceId, long timeBucket, CPU cpu) { + ServiceInstanceJVMCPU serviceInstanceJVMCPU = new ServiceInstanceJVMCPU(); + serviceInstanceJVMCPU.setId(serviceInstanceId); + serviceInstanceJVMCPU.setName(Const.EMPTY_STRING); + serviceInstanceJVMCPU.setServiceInstanceId(serviceInstanceId); + serviceInstanceJVMCPU.setServiceName(Const.EMPTY_STRING); + serviceInstanceJVMCPU.setUsePercent(cpu.getUsagePercent()); + serviceInstanceJVMCPU.setTimeBucket(timeBucket); + sourceReceiver.receive(serviceInstanceJVMCPU); + } + + private void sendToGCMetricProcess(int serviceInstanceId, long timeBucket, List gcs) { + gcs.forEach(gc -> { + ServiceInstanceJVMGC serviceInstanceJVMGC = new ServiceInstanceJVMGC(); + serviceInstanceJVMGC.setId(serviceInstanceId); + serviceInstanceJVMGC.setName(Const.EMPTY_STRING); + serviceInstanceJVMGC.setServiceInstanceId(serviceInstanceId); + serviceInstanceJVMGC.setServiceName(Const.EMPTY_STRING); + + switch (gc.getPhrase()) { + case NEW: + serviceInstanceJVMGC.setPhrase(GCPhrase.NEW); + case OLD: + serviceInstanceJVMGC.setPhrase(GCPhrase.OLD); + } + + serviceInstanceJVMGC.setTime(gc.getTime()); + serviceInstanceJVMGC.setCount(gc.getCount()); + serviceInstanceJVMGC.setTimeBucket(timeBucket); + sourceReceiver.receive(serviceInstanceJVMGC); + }); + } + + private void sendToMemoryMetricProcess(int serviceInstanceId, long timeBucket, List memories) { + memories.forEach(memory -> { + ServiceInstanceJVMMemory serviceInstanceJVMMemory = new ServiceInstanceJVMMemory(); + serviceInstanceJVMMemory.setId(serviceInstanceId); + serviceInstanceJVMMemory.setName(Const.EMPTY_STRING); + serviceInstanceJVMMemory.setServiceInstanceId(serviceInstanceId); + serviceInstanceJVMMemory.setServiceName(Const.EMPTY_STRING); + serviceInstanceJVMMemory.setHeap(memory.getIsHeap()); + serviceInstanceJVMMemory.setInit(memory.getInit()); + serviceInstanceJVMMemory.setMax(memory.getMax()); + serviceInstanceJVMMemory.setUsed(memory.getUsed()); + serviceInstanceJVMMemory.setCommitted(memory.getCommitted()); + serviceInstanceJVMMemory.setTimeBucket(timeBucket); + sourceReceiver.receive(serviceInstanceJVMMemory); + }); + } + + private void sendToMemoryPoolMetricProcess(int serviceInstanceId, long timeBucket, + List memoryPools) { + + memoryPools.forEach(memoryPool -> { + ServiceInstanceJVMMemoryPool serviceInstanceJVMMemoryPool = new ServiceInstanceJVMMemoryPool(); + serviceInstanceJVMMemoryPool.setId(serviceInstanceId); + serviceInstanceJVMMemoryPool.setName(Const.EMPTY_STRING); + serviceInstanceJVMMemoryPool.setServiceInstanceId(serviceInstanceId); + serviceInstanceJVMMemoryPool.setServiceName(Const.EMPTY_STRING); + + switch (memoryPool.getType()) { + case NEWGEN_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.NEWGEN_USAGE); + case OLDGEN_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.OLDGEN_USAGE); + case PERMGEN_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.PERMGEN_USAGE); + case SURVIVOR_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.SURVIVOR_USAGE); + case METASPACE_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.METASPACE_USAGE); + case CODE_CACHE_USAGE: + serviceInstanceJVMMemoryPool.setPoolType(MemoryPoolType.CODE_CACHE_USAGE); + } + + serviceInstanceJVMMemoryPool.setInit(memoryPool.getInit()); + serviceInstanceJVMMemoryPool.setMax(memoryPool.getMax()); + serviceInstanceJVMMemoryPool.setUsed(memoryPool.getUsed()); + serviceInstanceJVMMemoryPool.setCommitted(memoryPool.getCommited()); + serviceInstanceJVMMemoryPool.setTimeBucket(timeBucket); + sourceReceiver.receive(serviceInstanceJVMMemoryPool); + }); + } + + private void sendToInstanceHeartBeatProcess(int instanceId, long heartBeatTime) { +// instanceHeartBeatService.heartBeat(instanceId, heartBeatTime); + } +} diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleDefine b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleDefine new file mode 100644 index 000000000..fe4dab339 --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleDefine @@ -0,0 +1,19 @@ +# +# 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. +# +# + +org.apache.skywalking.oap.server.receiver.jvm.module.JVMModule \ No newline at end of file diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider new file mode 100644 index 000000000..4b3751feb --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/main/resources/META-INF/services/org.apache.skywalking.oap.server.library.module.ModuleProvider @@ -0,0 +1,19 @@ +# +# 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. +# +# + +org.apache.skywalking.oap.server.receiver.jvm.provider.JVMModuleProvider \ No newline at end of file diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandlerMainTest.java b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandlerMainTest.java new file mode 100644 index 000000000..ffa2c8df5 --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/java/org/apache/skywalking/oap/server/receiver/jvm/provider/handler/JVMMetricsServiceHandlerMainTest.java @@ -0,0 +1,137 @@ +/* + * 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. + * + */ + +package org.apache.skywalking.oap.server.receiver.jvm.provider.handler; + +import io.grpc.*; +import org.apache.skywalking.apm.network.language.agent.*; + +/** + * @author peng-yongsheng + */ +public class JVMMetricsServiceHandlerMainTest { + + public static void main(String[] args) { + ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 11800).usePlaintext(true).build(); + + JVMMetricsServiceGrpc.JVMMetricsServiceBlockingStub stub = JVMMetricsServiceGrpc.newBlockingStub(channel); + + JVMMetrics.Builder jvmMetrics = JVMMetrics.newBuilder(); + jvmMetrics.setApplicationInstanceId(1); + + JVMMetric.Builder jvmMetricBuilder = JVMMetric.newBuilder(); + jvmMetricBuilder.setTime(System.currentTimeMillis()); + + buildCPUMetric(jvmMetricBuilder); + buildGCMetric(jvmMetricBuilder); + buildMemoryMetric(jvmMetricBuilder); + buildMemoryPoolMetric(jvmMetricBuilder); + + jvmMetrics.addMetrics(jvmMetricBuilder); + + stub.collect(jvmMetrics.build()); + } + + private static void buildMemoryPoolMetric(JVMMetric.Builder metricBuilder) { + MemoryPool.Builder codeCache = MemoryPool.newBuilder(); + codeCache.setInit(10); + codeCache.setMax(100); + codeCache.setCommited(10); + codeCache.setUsed(50); + codeCache.setType(PoolType.CODE_CACHE_USAGE); + metricBuilder.addMemoryPool(codeCache); + + MemoryPool.Builder newGen = MemoryPool.newBuilder(); + newGen.setInit(10); + newGen.setMax(100); + newGen.setCommited(10); + newGen.setUsed(50); + newGen.setType(PoolType.NEWGEN_USAGE); + metricBuilder.addMemoryPool(newGen); + + MemoryPool.Builder oldGen = MemoryPool.newBuilder(); + oldGen.setInit(10); + oldGen.setMax(100); + oldGen.setCommited(10); + oldGen.setUsed(50); + oldGen.setType(PoolType.OLDGEN_USAGE); + metricBuilder.addMemoryPool(oldGen); + + MemoryPool.Builder survivor = MemoryPool.newBuilder(); + survivor.setInit(10); + survivor.setMax(100); + survivor.setCommited(10); + survivor.setUsed(50); + survivor.setType(PoolType.SURVIVOR_USAGE); + metricBuilder.addMemoryPool(survivor); + + MemoryPool.Builder permGen = MemoryPool.newBuilder(); + permGen.setInit(10); + permGen.setMax(100); + permGen.setCommited(10); + permGen.setUsed(50); + permGen.setType(PoolType.PERMGEN_USAGE); + metricBuilder.addMemoryPool(permGen); + + MemoryPool.Builder metaSpace = MemoryPool.newBuilder(); + metaSpace.setInit(10); + metaSpace.setMax(100); + metaSpace.setCommited(10); + metaSpace.setUsed(50); + metaSpace.setType(PoolType.METASPACE_USAGE); + metricBuilder.addMemoryPool(metaSpace); + } + + private static void buildMemoryMetric(JVMMetric.Builder metricBuilder) { + Memory.Builder isHeap = Memory.newBuilder(); + isHeap.setInit(20); + isHeap.setMax(100); + isHeap.setCommitted(20); + isHeap.setUsed(60); + isHeap.setIsHeap(true); + metricBuilder.addMemory(isHeap); + + Memory.Builder nonHeap = Memory.newBuilder(); + nonHeap.setInit(20); + nonHeap.setMax(100); + nonHeap.setCommitted(20); + nonHeap.setUsed(60); + nonHeap.setIsHeap(false); + metricBuilder.addMemory(nonHeap); + } + + private static void buildGCMetric(JVMMetric.Builder metricBuilder) { + GC.Builder newGC = GC.newBuilder(); + newGC.setPhrase(GCPhrase.NEW); + newGC.setCount(2); + newGC.setTime(1000); + metricBuilder.addGc(newGC); + + GC.Builder oldGC = GC.newBuilder(); + oldGC.setPhrase(GCPhrase.OLD); + oldGC.setCount(4); + oldGC.setTime(49); + metricBuilder.addGc(oldGC); + } + + private static void buildCPUMetric(JVMMetric.Builder metricBuilder) { + CPU.Builder cpu = CPU.newBuilder(); + cpu.setUsagePercent(20); + metricBuilder.setCpu(cpu.build()); + } +} diff --git a/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/resources/log4j2.xml b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/resources/log4j2.xml new file mode 100644 index 000000000..cd672826b --- /dev/null +++ b/oap-server/server-receiver-plugin/skywalking-jvm-receiver-plugin/src/test/resources/log4j2.xml @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + diff --git a/oap-server/server-starter/pom.xml b/oap-server/server-starter/pom.xml index 00fb0c425..9d0ddd0d4 100644 --- a/oap-server/server-starter/pom.xml +++ b/oap-server/server-starter/pom.xml @@ -74,6 +74,11 @@ skywalking-register-receiver-plugin ${project.version} + + org.apache.skywalking + skywalking-jvm-receiver-plugin + ${project.version} + diff --git a/oap-server/server-starter/src/main/resources/application.yml b/oap-server/server-starter/src/main/resources/application.yml index cdce1cb28..004745a01 100644 --- a/oap-server/server-starter/src/main/resources/application.yml +++ b/oap-server/server-starter/src/main/resources/application.yml @@ -51,6 +51,8 @@ storage: monthMetricDataTTL: 18 # Unit is month receiver-register: default: +receiver-jvm: + default: service-mesh: default: istio-telemetry: diff --git a/oap-server/server-storage-plugin/storage-elasticsearch-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch/base/ElasticSearchColumnTypeMappingTestCase.java b/oap-server/server-storage-plugin/storage-elasticsearch-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch/base/ElasticSearchColumnTypeMappingTestCase.java index 2553ab7b9..24d78f01c 100644 --- a/oap-server/server-storage-plugin/storage-elasticsearch-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch/base/ElasticSearchColumnTypeMappingTestCase.java +++ b/oap-server/server-storage-plugin/storage-elasticsearch-plugin/src/test/java/org/apache/skywalking/oap/server/storage/plugin/elasticsearch/base/ElasticSearchColumnTypeMappingTestCase.java @@ -38,6 +38,6 @@ public class ElasticSearchColumnTypeMappingTestCase { Assert.assertEquals("double", mapping.transform(double.class)); Assert.assertEquals("double", mapping.transform(Double.class)); - Assert.assertEquals("text", mapping.transform(String.class)); + Assert.assertEquals("keyword", mapping.transform(String.class)); } }