diff --git a/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALLexer.g4 b/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALLexer.g4 index c9fb8893f9148ad3e4b32851f4e221c35623908d..af1e3a7bff192f8a7f89c7750e329a8f08642632 100644 --- a/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALLexer.g4 +++ b/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALLexer.g4 @@ -49,7 +49,7 @@ BOOL_LITERAL: 'true' | 'false' ; -INT_LITERAL : Digits+; +NUMBER_LITERAL : Digits+; CHAR_LITERAL: '\'' (~['\\\r\n] | EscapeSequence) '\''; @@ -111,4 +111,8 @@ COMMA: ','; SEMI: ';'; EQUAL: '='; DUALEQUALS: '=='; -ALL: '*'; \ No newline at end of file +ALL: '*'; +GREATER: '>'; +LESS: '<'; +GREATER_EQUAL: '>='; +LESS_EQUAL: '<='; \ No newline at end of file diff --git a/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALParser.g4 b/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALParser.g4 index 086348c2ca6620cca030af632e9b5932f21554ad..35b20bdca1c50dd6273353dbff04f2e2d75846a1 100644 --- a/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALParser.g4 +++ b/oap-server/generate-tool-grammar/src/main/antlr4/org/apache/skywalking/oal/tool/grammar/OALParser.g4 @@ -74,11 +74,11 @@ funcParamExpression ; literalExpression - : BOOL_LITERAL | INT_LITERAL + : BOOL_LITERAL | NUMBER_LITERAL ; expression - : booleanMatch | stringMatch + : booleanMatch | stringMatch | greaterMatch | lessMatch | greaterEqualMatch | lessEqualMatch ; booleanMatch @@ -89,6 +89,22 @@ stringMatch : conditionAttribute DUALEQUALS (stringConditionValue | enumConditionValue) ; +greaterMatch + : conditionAttribute GREATER numberConditionValue + ; + +lessMatch + : conditionAttribute LESS numberConditionValue + ; + +greaterEqualMatch + : conditionAttribute GREATER_EQUAL numberConditionValue + ; + +lessEqualMatch + : conditionAttribute LESS_EQUAL numberConditionValue + ; + conditionAttribute : IDENTIFIER ; @@ -103,4 +119,8 @@ stringConditionValue enumConditionValue : IDENTIFIER DOT IDENTIFIER + ; + +numberConditionValue + : NUMBER_LITERAL ; \ No newline at end of file diff --git a/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/DeepAnalysis.java b/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/DeepAnalysis.java index 6d479a80b0d54131d236eb78aef143d572cf63b3..34d8a633cce96a70bb6458a8a15111a2752c4bf4 100644 --- a/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/DeepAnalysis.java +++ b/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/DeepAnalysis.java @@ -51,6 +51,26 @@ public class DeepAnalysis { filterExpression.setLeft("source." + ClassMethodUtil.toGetMethod(expression.getAttribute()) + "()"); filterExpression.setRight(expression.getValue()); result.addFilterExpressions(filterExpression); + } else if ("greaterMatch".equals(expression.getExpressionType())) { + filterExpression.setExpressionObject("GreaterMatch"); + filterExpression.setLeft("source." + ClassMethodUtil.toGetMethod(expression.getAttribute()) + "()"); + filterExpression.setRight(expression.getValue()); + result.addFilterExpressions(filterExpression); + } else if ("lessMatch".equals(expression.getExpressionType())) { + filterExpression.setExpressionObject("LessMatch"); + filterExpression.setLeft("source." + ClassMethodUtil.toGetMethod(expression.getAttribute()) + "()"); + filterExpression.setRight(expression.getValue()); + result.addFilterExpressions(filterExpression); + } else if ("greaterEqualMatch".equals(expression.getExpressionType())) { + filterExpression.setExpressionObject("GreaterEqualMatch"); + filterExpression.setLeft("source." + ClassMethodUtil.toGetMethod(expression.getAttribute()) + "()"); + filterExpression.setRight(expression.getValue()); + result.addFilterExpressions(filterExpression); + } else if ("lessEqualMatch".equals(expression.getExpressionType())) { + filterExpression.setExpressionObject("LessEqualMatch"); + filterExpression.setLeft("source." + ClassMethodUtil.toGetMethod(expression.getAttribute()) + "()"); + filterExpression.setRight(expression.getValue()); + result.addFilterExpressions(filterExpression); } else { throw new IllegalArgumentException("filter expression [" + expression.getExpressionType() + "] not found"); } diff --git a/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/OALListener.java b/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/OALListener.java index 2e585a33d0b3d129561a413158bf330a88cac505..a52cc74ed45aafe33bf44367fa62a9cba6b302fe 100644 --- a/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/OALListener.java +++ b/oap-server/generate-tool/src/main/java/org/apache/skywalking/oal/tool/parser/OALListener.java @@ -101,6 +101,22 @@ public class OALListener extends OALParserBaseListener { conditionExpression.setExpressionType("stringMatch"); } + @Override public void enterGreaterMatch(OALParser.GreaterMatchContext ctx) { + conditionExpression.setExpressionType("greaterMatch"); + } + + @Override public void enterGreaterEqualMatch(OALParser.GreaterEqualMatchContext ctx) { + conditionExpression.setExpressionType("greaterEqualMatch"); + } + + @Override public void enterLessMatch(OALParser.LessMatchContext ctx) { + conditionExpression.setExpressionType("lessMatch"); + } + + @Override public void enterLessEqualMatch(OALParser.LessEqualMatchContext ctx) { + conditionExpression.setExpressionType("lessEqualMatch"); + } + @Override public void enterBooleanConditionValue(OALParser.BooleanConditionValueContext ctx) { conditionExpression.setValue(ctx.getText()); } @@ -113,6 +129,10 @@ public class OALListener extends OALParserBaseListener { conditionExpression.setValue(ctx.getText()); } + @Override public void enterNumberConditionValue(OALParser.NumberConditionValueContext ctx) { + conditionExpression.setValue(ctx.getText()); + } + ///////////// // Expression end. //////////// diff --git a/oap-server/generate-tool/src/main/resources/code-templates/DispatcherTemplate.ftl b/oap-server/generate-tool/src/main/resources/code-templates/DispatcherTemplate.ftl index b6068cac4b3497cf04dad6d65860bfeed55532b6..f814d727e0a38116fe1b7caa77399021dbc52682 100644 --- a/oap-server/generate-tool/src/main/resources/code-templates/DispatcherTemplate.ftl +++ b/oap-server/generate-tool/src/main/resources/code-templates/DispatcherTemplate.ftl @@ -49,9 +49,15 @@ public class ${source}Dispatcher implements SourceDispatcher<${source}> { <#if indicator.filterExpressions??> <#list indicator.filterExpressions as filterExpression> + <#if filterExpression.expressionObject == "GreaterMatch" || filterExpression.expressionObject == "LessMatch" || filterExpression.expressionObject == "GreaterEqualMatch" || filterExpression.expressionObject == "LessEqualMatch"> + if (!new ${filterExpression.expressionObject}().match(${filterExpression.left}, ${filterExpression.right})) { + return; + } + <#else> if (!new ${filterExpression.expressionObject}().setLeft(${filterExpression.left}).setRight(${filterExpression.right}).match()) { return; } + diff --git a/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/output/FileGeneratorTest.java b/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/output/FileGeneratorTest.java index 1740a1df0528645eaf818bd67bc173c6212a365b..7207a50085ab7d7344603685bce5f9b650e7e92f 100644 --- a/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/output/FileGeneratorTest.java +++ b/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/output/FileGeneratorTest.java @@ -46,11 +46,17 @@ public class FileGeneratorTest { result.setAggregationFunctionName("avg"); result.setIndicatorClassName("LongAvgIndicator"); - FilterExpression expression = new FilterExpression(); - expression.setExpressionObject("EqualMatch"); - expression.setLeft("source.getName()"); - expression.setRight("\"/service/prod/save\""); - result.addFilterExpressions(expression); + FilterExpression equalExpression = new FilterExpression(); + equalExpression.setExpressionObject("EqualMatch"); + equalExpression.setLeft("source.getName()"); + equalExpression.setRight("\"/service/prod/save\""); + result.addFilterExpressions(equalExpression); + + FilterExpression greaterExpression = new FilterExpression(); + greaterExpression.setExpressionObject("GreaterMatch"); + greaterExpression.setLeft("source.getLatency()"); + greaterExpression.setRight("1000"); + result.addFilterExpressions(greaterExpression); EntryMethod method = new EntryMethod(); method.setMethodName("combine"); @@ -96,7 +102,7 @@ public class FileGeneratorTest { fileGenerator.generateDispatcher(result, writer); Assert.assertEquals(readExpectedFile("ServiceDispatcherExpected.java"), writer.toString()); - //fileGenerator.generateServiceDispatcher(new OutputStreamWriter(System.out)); +// fileGenerator.generateDispatcher(result, new OutputStreamWriter(System.out)); } private String readExpectedFile(String filename) throws IOException { diff --git a/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/parser/ScriptParserTest.java b/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/parser/ScriptParserTest.java index 58cb8384d264929c4f980dbf6c93cee38ec2cc43..cab3a935c98f4abf5908ed7d649f7a1098277976 100644 --- a/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/parser/ScriptParserTest.java +++ b/oap-server/generate-tool/src/test/java/org/apache/skywalking/oal/tool/parser/ScriptParserTest.java @@ -112,4 +112,59 @@ public class ScriptParserTest { Assert.assertEquals("\"/product/abc\"", stringMatchExp.getValue()); Assert.assertEquals("stringMatch", stringMatchExp.getExpressionType()); } + + @Test + public void testParse4() throws IOException { + ScriptParser parser = ScriptParser.createFromScriptText( + "service_response_s1_summary = from(Service.latency).filter(latency > 1000).sum();" + "\n" + + "service_response_s2_summary = from(Service.latency).filter(latency < 2000).sum();" + "\n" + + "service_response_s3_summary = from(Service.latency).filter(latency >= 3000).sum();" + "\n" + + "service_response_s4_summary = from(Service.latency).filter(latency <= 4000).sum();" + ); + List results = parser.parse(); + + AnalysisResult responseSummary = results.get(0); + Assert.assertEquals("ServiceResponseS1Summary", responseSummary.getMetricName()); + Assert.assertEquals("Service", responseSummary.getSourceName()); + Assert.assertEquals("latency", responseSummary.getSourceAttribute()); + Assert.assertEquals("sum", responseSummary.getAggregationFunctionName()); + List expressions = responseSummary.getFilterExpressionsParserResult(); + + Assert.assertEquals(1, expressions.size()); + + ConditionExpression booleanMatchExp = expressions.get(0); + Assert.assertEquals("latency", booleanMatchExp.getAttribute()); + Assert.assertEquals("1000", booleanMatchExp.getValue()); + Assert.assertEquals("greaterMatch", booleanMatchExp.getExpressionType()); + + responseSummary = results.get(1); + expressions = responseSummary.getFilterExpressionsParserResult(); + + Assert.assertEquals(1, expressions.size()); + + booleanMatchExp = expressions.get(0); + Assert.assertEquals("latency", booleanMatchExp.getAttribute()); + Assert.assertEquals("2000", booleanMatchExp.getValue()); + Assert.assertEquals("lessMatch", booleanMatchExp.getExpressionType()); + + responseSummary = results.get(2); + expressions = responseSummary.getFilterExpressionsParserResult(); + + Assert.assertEquals(1, expressions.size()); + + booleanMatchExp = expressions.get(0); + Assert.assertEquals("latency", booleanMatchExp.getAttribute()); + Assert.assertEquals("3000", booleanMatchExp.getValue()); + Assert.assertEquals("greaterEqualMatch", booleanMatchExp.getExpressionType()); + + responseSummary = results.get(3); + expressions = responseSummary.getFilterExpressionsParserResult(); + + Assert.assertEquals(1, expressions.size()); + + booleanMatchExp = expressions.get(0); + Assert.assertEquals("latency", booleanMatchExp.getAttribute()); + Assert.assertEquals("4000", booleanMatchExp.getValue()); + Assert.assertEquals("lessEqualMatch", booleanMatchExp.getExpressionType()); + } } diff --git a/oap-server/generate-tool/src/test/resources/expectedFiles/ServiceDispatcherExpected.java b/oap-server/generate-tool/src/test/resources/expectedFiles/ServiceDispatcherExpected.java index b0a6a1d1a3363254f536e41d6eb2ec1d2f5a4212..d673df7057cc57b8f819e0c1f1f62b0cf46ab63e 100644 --- a/oap-server/generate-tool/src/test/resources/expectedFiles/ServiceDispatcherExpected.java +++ b/oap-server/generate-tool/src/test/resources/expectedFiles/ServiceDispatcherExpected.java @@ -40,6 +40,9 @@ public class ServiceDispatcher implements SourceDispatcher { if (!new EqualMatch().setLeft(source.getName()).setRight("/service/prod/save").match()) { return; } + if (!new GreaterMatch().match(source.getLatency(), 1000)) { + return; + } indicator.setTimeBucket(source.getTimeBucket()); indicator.setEntityId(source.getEntityId()); diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterEqualMatch.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterEqualMatch.java new file mode 100644 index 0000000000000000000000000000000000000000..a0de184d5641c7122505c5d7456c149b3751ad8a --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterEqualMatch.java @@ -0,0 +1,41 @@ +/* + * 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.expression; + +/** + * @author peng-yongsheng + */ +public class GreaterEqualMatch { + + public boolean match(Integer left, Integer right) { + return left >= right; + } + + public boolean match(Long left, Long right) { + return left >= right; + } + + public boolean match(Float left, Float right) { + return left >= right; + } + + public boolean match(Double left, Double right) { + return left >= right; + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterMatch.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterMatch.java new file mode 100644 index 0000000000000000000000000000000000000000..ac14097eb26a19152528e2011e727112962d9da8 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterMatch.java @@ -0,0 +1,41 @@ +/* + * 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.expression; + +/** + * @author peng-yongsheng + */ +public class GreaterMatch { + + public boolean match(Integer left, Integer right) { + return left > right; + } + + public boolean match(Long left, Long right) { + return left > right; + } + + public boolean match(Float left, Float right) { + return left > right; + } + + public boolean match(Double left, Double right) { + return left > right; + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessEqualMatch.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessEqualMatch.java new file mode 100644 index 0000000000000000000000000000000000000000..a07260d46af6d34a6011bffb91bc840bc462d486 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessEqualMatch.java @@ -0,0 +1,41 @@ +/* + * 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.expression; + +/** + * @author peng-yongsheng + */ +public class LessEqualMatch { + + public boolean match(Integer left, Integer right) { + return left <= right; + } + + public boolean match(Long left, Long right) { + return left <= right; + } + + public boolean match(Float left, Float right) { + return left <= right; + } + + public boolean match(Double left, Double right) { + return left <= right; + } +} diff --git a/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessMatch.java b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessMatch.java new file mode 100644 index 0000000000000000000000000000000000000000..3d78ca17e2118061b2a70cee053b20bd01ac8398 --- /dev/null +++ b/oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessMatch.java @@ -0,0 +1,41 @@ +/* + * 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.expression; + +/** + * @author peng-yongsheng + */ +public class LessMatch { + + public boolean match(Integer left, Integer right) { + return left < right; + } + + public boolean match(Long left, Long right) { + return left < right; + } + + public boolean match(Float left, Float right) { + return left < right; + } + + public boolean match(Double left, Double right) { + return left < right; + } +}