From 940130e24a2a18aa164bf5c9b98a0b72919e4c99 Mon Sep 17 00:00:00 2001 From: peng-yongsheng Date: Sun, 17 Mar 2019 00:15:51 +0800 Subject: [PATCH] Added 4 expressions in OAL syntax: >, <, >=, <= --- .../skywalking/oal/tool/grammar/OALLexer.g4 | 8 ++- .../skywalking/oal/tool/grammar/OALParser.g4 | 24 +++++++- .../oal/tool/parser/DeepAnalysis.java | 20 +++++++ .../oal/tool/parser/OALListener.java | 20 +++++++ .../code-templates/DispatcherTemplate.ftl | 6 ++ .../oal/tool/output/FileGeneratorTest.java | 18 ++++-- .../oal/tool/parser/ScriptParserTest.java | 55 +++++++++++++++++++ .../expression/GreaterEqualMatch.java | 41 ++++++++++++++ .../indicator/expression/GreaterMatch.java | 41 ++++++++++++++ .../indicator/expression/LessEqualMatch.java | 41 ++++++++++++++ .../indicator/expression/LessMatch.java | 41 ++++++++++++++ 11 files changed, 305 insertions(+), 10 deletions(-) create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterEqualMatch.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/GreaterMatch.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessEqualMatch.java create mode 100644 oap-server/server-core/src/main/java/org/apache/skywalking/oap/server/core/analysis/indicator/expression/LessMatch.java 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 c9fb8893f..af1e3a7bf 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 086348c2c..35b20bdca 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 6d479a80b..34d8a633c 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 2e585a33d..a52cc74ed 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 b6068cac4..f814d727e 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 1740a1df0..7207a5008 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 58cb8384d..cab3a935c 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/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 000000000..a0de184d5 --- /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 000000000..ac14097eb --- /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 000000000..75b68d3c5 --- /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 000000000..7cf5fd75d --- /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; + } +}