From e5b7380c874745c989d1816b8f552504f038e1bc Mon Sep 17 00:00:00 2001 From: lresende Date: Thu, 26 Sep 2013 20:33:20 +0000 Subject: 2.0 branch for possible maintenance release git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1526672 13f79535-47bb-0310-9956-ffa450edef68 --- .../apache/tuscany/sca/aspectj/LoggingAspect.java | 102 +++++++++++++++++++++ .../tuscany/sca/aspectj/SimpleTracingAspect.java | 85 +++++++++++++++++ .../apache/tuscany/sca/aspectj/TimingAspect.java | 53 +++++++++++ .../apache/tuscany/sca/aspectj/TracingAspect.java | 92 +++++++++++++++++++ .../tuscany/sca/aspectj/UserTimingAspect.java | 45 +++++++++ 5 files changed, 377 insertions(+) create mode 100644 sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/LoggingAspect.java create mode 100644 sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/SimpleTracingAspect.java create mode 100644 sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TimingAspect.java create mode 100644 sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TracingAspect.java create mode 100644 sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/UserTimingAspect.java (limited to 'sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache') diff --git a/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/LoggingAspect.java b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/LoggingAspect.java new file mode 100644 index 0000000000..2836e90e19 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/LoggingAspect.java @@ -0,0 +1,102 @@ +/* + * 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.tuscany.sca.aspectj; + +import java.util.Arrays; + +import org.aspectj.lang.JoinPoint; +import org.aspectj.lang.annotation.AfterReturning; +import org.aspectj.lang.annotation.AfterThrowing; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Before; +import org.aspectj.lang.annotation.Pointcut; + +/** + * LoggingAspect performs standard logging of method signatures, arguments, and + * return values. All Tuscany methods, constructors, and statics are logged. + * @version $Rev$ $Date$ + */ +@Aspect +public class LoggingAspect { + @Pointcut("call(* org.apache.tuscany.sca..*(..)) && (!within(org.apache.tuscany.sca.aspectj.*Aspect))") + public void anyMethodCall() { + } + + @Pointcut("execution(* org.apache.tuscany.sca..*(..)) && (!within(org.apache.tuscany.sca.aspectj.*Aspect))") + public void anyMethodExecution() { + } + + @Pointcut("call(* java.util.logging.Logger.info(..))") + public void anyLogCall() { + } + + @Pointcut("cflow(anyMethodExecution()) && anyLogCall()") + public void anyLog() { + } + + @Pointcut("call(org.apache.tuscany.sca..*.new(..))") + public void anyConstructor() { + } + + // e.g. org.apache.tuscany.sca.implementation.java.introspect.impl.JavaIntrospectionHelper + @Pointcut("staticinitialization(org.apache.tuscany.sca.implementation..*)") + public void anyStatic() { + } + + @Before("anyMethodCall()") + public void before(JoinPoint jp) { + // System.out.println("Logging anyMethodCall before jp=" + jp); + // System.out.println("Logging anyMethodCall before jp.getSourceLocation=" + jp.getSourceLocation()); + // System.out.println("Logging anyMethodCall before jp.getThis=" + jp.getThis()); + // System.out.println("Logging anyMethodCall before jp.getTarget=" + jp.getTarget()); + System.out.println("Logging Before anyMethodCall jp.getSignature=" + jp.getSignature()); + java.lang.Object[] args = jp.getArgs(); + if (( args != null ) && ( args.length > 0 )) { + System.out.println("Logging Before anyMethodCall jp.getArgs=" + Arrays.asList(args)); + } + } + + @AfterReturning(pointcut = "anyMethodCall()", returning = "result") + public void afterReturning(JoinPoint jp, Object result) { + // Note that result is null for methods with void return. + System.out.println("Logging AfterReturning anyMethodCall jp=" + jp + ", result=" + result); + } + + @AfterThrowing(pointcut = "anyMethodCall()", throwing = "t") + public void afterThrowing(JoinPoint jp, Throwable t) { + System.out.println("Logging AfterThrowing anyMethodCall jp=" + jp + ", t=" + t); + } + + @Before("anyConstructor()") + public void beforeConstructor(JoinPoint jp) { + System.out.println("Logging Before anyConstructor jp.getSignature=" + jp.getSignature()); + java.lang.Object[] args = jp.getArgs(); + if (( args != null ) && ( args.length > 0 )) { + System.out.println("Logging Before anyConstructor jp.getArgs=" + Arrays.asList(args)); + } + } + + @Before("anyStatic()") + public void beforeStatic(JoinPoint jp) { + System.out.println("Logging Before anyStatic before jp=" + jp); + System.out.println("Logging anyMethodCall before jp.getSourceLocation=" + jp.getSourceLocation()); + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/SimpleTracingAspect.java b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/SimpleTracingAspect.java new file mode 100644 index 0000000000..83a06a771e --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/SimpleTracingAspect.java @@ -0,0 +1,85 @@ +/* + * 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.tuscany.sca.aspectj; + +import org.aspectj.lang.JoinPoint; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Pointcut; + +/** + * SimpleTraceAspect performs tracing of method signatures, arguments, and + * return values. All Tuscany methods, constructors, and statics are traced. + * + * @version $Rev$ $Date$ + */ +@Aspect +public class SimpleTracingAspect extends TracingAspect { + + @Pointcut("execution(public * org.apache.tuscany.sca..*.*(..))") + // @Pointcut("call(* org.apache.tuscany.sca..*(..))") + protected void entry() { + } + + @Pointcut("within(org.apache.tuscany.sca..*) && !within(org.apache.tuscany.sca.aspectj..*Aspect)") + protected void withinScope() { + } + + @Override + protected void startLog() { + System.out.println(">>> ----------------------------------------------------"); + } + + @Override + protected void completeLog() { + System.out.println("<<< ----------------------------------------------------"); + } + + @Override + protected void logEnter(JoinPoint jp) { + System.out.println("> logEnter jp.getSignature=" + jp.getSignature()); + java.lang.Object[] args = jp.getArgs(); + if (( args != null ) && ( args.length > 0 )) { + // See http://www.eclipse.org/aspectj/doc/released/progguide/pitfalls-infiniteLoops.html + // System.out.println("Logging anyMethodCall before jp.getArgs=" + Arrays.asList(args)); + System.out.print(" logEnter jp.getArgs(" + args.length + ")=[" ); + for ( int i = 0; i < args.length; i++ ){ + if ( i > 0 ) System.out.print( ","); + System.out.print( args[ i ]); + } + System.out.println("]" ); + } + } + + @Override + protected void logExit(JoinPoint jp, Object result) { + // Note that result is null for methods with void return. + System.out.println("< logExit jp.getSignature=" + jp.getSignature() +", result=" + result ); + } + + @Override + protected void logThrowable(JoinPoint jp, Throwable throwable) { + while ( throwable.getCause() != null ) + throwable = throwable.getCause(); + System.out.println("! logThrowable jp.getSignature=" + jp.getSignature() + ", throwable=" + throwable); + // System.out.println("! logThowable stackTrace=" ); + // throwable.printStackTrace( System.out ); + } + +} diff --git a/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TimingAspect.java b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TimingAspect.java new file mode 100644 index 0000000000..8bde1d4f91 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TimingAspect.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.tuscany.sca.aspectj; + +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Pointcut; + +/** + * The TimingAspect is used to perform timing metrics on various calls. + * The Pointcut "timedCall" is not defined here, but rather in the aop.xml + * configuration file. You may provide a point cut to state which type + * of call you would like timed and reported in the output files. + * + * @version $Rev$ $Date$ + */ +@Aspect +public abstract class TimingAspect { + // Abstract pointcut. Pointcut is defined in aop.xml file. + @Pointcut + public void timedCall() { + } + + @Around("timedCall()") + public Object timedSection(ProceedingJoinPoint jp) throws Throwable { + System.out.println("Timing Around timedSection jp=" + jp); + long start = System.currentTimeMillis(); + try { + return jp.proceed(); + } finally { + long end = System.currentTimeMillis(); + System.out.println("Timing Around timedSection Roundtrip is " + (end - start) + "ms for jp.getSignature=" + jp.getSignature()); + } + } +} diff --git a/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TracingAspect.java b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TracingAspect.java new file mode 100644 index 0000000000..0178ebdb6e --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/TracingAspect.java @@ -0,0 +1,92 @@ +/* + * 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.tuscany.sca.aspectj; + +import org.aspectj.lang.JoinPoint; +import org.aspectj.lang.annotation.After; +import org.aspectj.lang.annotation.AfterReturning; +import org.aspectj.lang.annotation.AfterThrowing; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Before; +import org.aspectj.lang.annotation.Pointcut; + +/** + * @version $Rev$ $Date$ + */ + +@Aspect +public abstract class TracingAspect { + + @Pointcut("") + protected abstract void entry(); + + @Pointcut("") + protected abstract void withinScope(); + + @Pointcut("call(* java..*.*(..))") + protected void exit() { + } + + @Pointcut("entry() && !cflowbelow(entry())") + void start() { + } + + // @Pointcut("withinScope() && cflow(entry()) && !cflow(exit()) && !within(org.apache.tuscany.sca.aspectj.*Aspect) && !within(*.toString)") + @Pointcut("withinScope() && entry()") + // @Pointcut("withinScope() && entry()&& !cflow(execution(String toString())") + void trace() { + } + + @Pointcut("!handler(*) && !preinitialization(new(..))") + protected void supportsAfterAdvice() { + } + + @Before("start()") + public void beforeStart() { + startLog(); + } + + @Before("trace() && supportsAfterAdvice()") + public void beforeTrace(JoinPoint jp) { + logEnter(jp); + } + + @AfterReturning(pointcut = "trace() && supportsAfterAdvice()", returning = "result") + public void afterReturning(JoinPoint jp, Object result) { + logExit(jp, result); + } + + @AfterThrowing(pointcut = "trace() && supportsAfterAdvice()", throwing = "e") + public void afterThrowing(JoinPoint jp, Throwable e) { + logThrowable(jp, e); + } + + @After("start()") + public void afterStart() { + completeLog(); + } + + protected abstract void logEnter(JoinPoint jp); + protected abstract void logExit(JoinPoint jp, Object result); + protected abstract void logThrowable(JoinPoint jp, Throwable throwable); + + protected abstract void startLog(); + protected abstract void completeLog(); +} diff --git a/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/UserTimingAspect.java b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/UserTimingAspect.java new file mode 100644 index 0000000000..a60bd0f883 --- /dev/null +++ b/sca-java-2.x/branches/2.0/modules/tracing-aspectj/src/main/java/org/apache/tuscany/sca/aspectj/UserTimingAspect.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.tuscany.sca.aspectj; + +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.aspectj.lang.annotation.Pointcut; + +@Aspect +public class UserTimingAspect { + @Pointcut + public void timedCall() { + + } + + @Around("timedCall()") + public Object timedSection(ProceedingJoinPoint jp) throws Throwable { + System.out.println("Timing Around timedSection jp=" + jp); + long start = System.currentTimeMillis(); + try { + return jp.proceed(); + } finally { + long end = System.currentTimeMillis(); + System.out.println("Timing Around timedSection Roundtrip is " + (end - start) + "ms for jp.getSignature=" + jp.getSignature()); + } + } +} -- cgit v1.2.3