diff --git a/src/main/java/kieker/analysis/TraceAnalysisConfiguration.java b/src/main/java/kieker/analysis/TraceAnalysisConfiguration.java
index 2c4c8c3dbda733bd4f0bf0c0b0c73061318d681e..7de800508604356673f06ae4ca068ec79e99e0ea 100644
--- a/src/main/java/kieker/analysis/TraceAnalysisConfiguration.java
+++ b/src/main/java/kieker/analysis/TraceAnalysisConfiguration.java
@@ -22,6 +22,7 @@ import kieker.analysis.trace.traversal.AggrTraceTraverserStage;
import kieker.analysis.trace.traversal.NamedGraph;
import kieker.analysis.trace.traversal.TraceTraverserStage;
import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
+import kieker.analysis.traceanalysisdomain.AggregatedTrace;
import kieker.analysis.traceanalysisdomain.OperationCall;
import kieker.analysis.traceanalysisdomain.Trace;
import kieker.common.record.IMonitoringRecord;
@@ -85,18 +86,21 @@ public class TraceAnalysisConfiguration extends Configuration {
super.connectPorts(graphDistributor.getNewOutputPort(), graphMLWriter.getInputPort());
super.connectPorts(graphDistributor.getNewOutputPort(), dotGraphWriter.getInputPort());
+ final Distributor<AggregatedTrace> aggregatedTraceDistributor = new Distributor<>(new CopyByReferenceStrategy());
AggrTraceTraverserStage aggrTraceTraverser = new AggrTraceTraverserStage();
final Distributor<NamedGraph<Graph>> graphDistributor2 = new Distributor<>(new CopyByReferenceStrategy());
GraphMLWriter graphMLWriter2 = new GraphMLWriter(graphFilesOutputDir);
DotGraphWriter dotGraphWriter2 = new DotGraphWriter(graphFilesOutputDir);
- super.connectPorts(aggregation.getOutputPort(), aggrTraceTraverser.getInputPort());
+ super.connectPorts(aggregation.getOutputPort(), aggregatedTraceDistributor.getInputPort());
+
+ super.connectPorts(aggregatedTraceDistributor.getNewOutputPort(), aggrTraceTraverser.getInputPort());
super.connectPorts(aggrTraceTraverser.getOutputPort(), graphDistributor2.getInputPort());
super.connectPorts(graphDistributor2.getNewOutputPort(), graphMLWriter2.getInputPort());
super.connectPorts(graphDistributor2.getNewOutputPort(), dotGraphWriter2.getInputPort());
DependencyCreatorStage dependencyCreatorStage = new DependencyCreatorStage();
- super.connectPorts(aggregation.getOutputPort(), dependencyCreatorStage.getInputPort());
+ super.connectPorts(aggregatedTraceDistributor.getNewOutputPort(), dependencyCreatorStage.getInputPort());
/*
*
diff --git a/src/main/java/kieker/analysis/dev/AggregatedTraceCallsDecorator.java b/src/main/java/kieker/analysis/dev/AggregatedTraceCallsDecorator.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebeaa804b7af86c906acd6b2bc4e5ef4beacbc3d
--- /dev/null
+++ b/src/main/java/kieker/analysis/dev/AggregatedTraceCallsDecorator.java
@@ -0,0 +1,59 @@
+package kieker.analysis.dev;
+
+import java.util.Iterator;
+
+import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
+import kieker.analysis.traceanalysisdomain.AggregatedTrace;
+import kieker.analysis.traceanalysisdomain.OperationCall;
+import kieker.analysis.traceanalysisdomain.Trace;
+
+import teetime.stage.basic.AbstractTransformation;
+
+/**
+ * This stage assigns normal {@link OperationCall} to {@link AggregatedOperationCall}.
+ *
+ * @author Sören Henning
+ *
+ */
+public class AggregatedTraceCallsDecorator extends AbstractTransformation<AggregatedTrace, AggregatedTrace> {
+
+ /*
+ * TODO Separate logic
+ *
+ * - use Visitor pattern
+ * - use a new trace traverser (AggTrace-List<Trace>-Traverser)
+ * - maybe the Trace-Traverser and AggTrace-List<Trace>-Traverser can share logic
+ *
+ */
+
+ @Override
+ protected void execute(final AggregatedTrace aggregatedTrace) {
+
+ AggregatedOperationCall aggregatedOperationCall = aggregatedTrace.getRootOperationCall();
+
+ for (Trace trace : aggregatedTrace.getTraces()) {
+
+ transformCall(aggregatedOperationCall, trace.getRootOperationCall());
+ }
+
+ this.getOutputPort().send(aggregatedTrace);
+ }
+
+ public void transformTrace(final AggregatedTrace aggregatedTrace, final Trace trace) {
+
+ transformCall(aggregatedTrace.getRootOperationCall(), trace.getRootOperationCall());
+ }
+
+ public void transformCall(final AggregatedOperationCall aggregatedOperationCall, final OperationCall operationCall) {
+
+ // This would be the visit() method
+ aggregatedOperationCall.addBaseOperationCall(operationCall);
+
+ Iterator<AggregatedOperationCall> aggCallIterator = aggregatedOperationCall.getChildren().iterator();
+ Iterator<OperationCall> callIterator = operationCall.getChildren().iterator();
+ while (aggCallIterator.hasNext() && callIterator.hasNext()) {
+ transformCall(aggCallIterator.next(), callIterator.next());
+ }
+ }
+
+}
diff --git a/src/main/java/kieker/analysis/dev/CollectedAggrOperationCall.java b/src/main/java/kieker/analysis/dev/CollectedAggrOperationCall.java
deleted file mode 100644
index 5f384b909e7869a0f3deefc99373fc7ff87492d2..0000000000000000000000000000000000000000
--- a/src/main/java/kieker/analysis/dev/CollectedAggrOperationCall.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package kieker.analysis.dev;
-
-import java.util.LinkedList;
-import java.util.List;
-
-import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
-import kieker.analysis.traceanalysisdomain.OperationCall;
-
-public class CollectedAggrOperationCall extends AggregatedOperationCall {
-
- private List<AggregatedOperationCall> baseOperationCalls = new LinkedList<>();
-
- public CollectedAggrOperationCall(final OperationCall call) {
- super(call);
- }
-
- public CollectedAggrOperationCall(final String container, final String component, final String operation, final int orderIndex, final String failedCause,
- final long totalDuration,
- final long medianDuration, final long minDuration, final long maxDuration, final long meanDuration, final int calls) {
- super(container, component, operation, orderIndex, failedCause, totalDuration, medianDuration, minDuration, maxDuration, meanDuration, calls);
- }
-
- public CollectedAggrOperationCall(final String container, final String component, final String operation, final int orderIndex, final String failedCause) {
- super(container, component, operation, orderIndex, failedCause);
- }
-
- public CollectedAggrOperationCall(final String container, final String component, final String operation, final int orderIndex) {
- super(container, component, operation, orderIndex);
- }
-
- public List<AggregatedOperationCall> getBaseOperationCalls() {
- return baseOperationCalls;
- }
-
- public void setBaseOperationCalls(final List<AggregatedOperationCall> baseOperationCalls) {
- this.baseOperationCalls = baseOperationCalls;
- }
-
- public void addBaseOperartionCall(final AggregatedOperationCall operationCall) {
- baseOperationCalls.add(operationCall);
- }
-
-}
diff --git a/src/main/java/kieker/analysis/dev/DependencyStatisticsDecorator.java b/src/main/java/kieker/analysis/dev/DependencyStatisticsDecorator.java
index b7cc85cda29fb2b15eed241b94b6a8ac82620f08..bf00261b2f0e719d6973d64d12406e07b0209921 100644
--- a/src/main/java/kieker/analysis/dev/DependencyStatisticsDecorator.java
+++ b/src/main/java/kieker/analysis/dev/DependencyStatisticsDecorator.java
@@ -4,14 +4,6 @@ public class DependencyStatisticsDecorator {
public void decorate(final OperationsDependency operationsDependency) {
- for (CollectedAggrOperationCall operation : operationsDependency.getOperations()) {
-
- // List<Long> durations = operation.getBaseOperationCalls().stream().map(call -> call.getDuration()).collect(Collectors.toList());
-
- // StatisticsUtility.calculateStatistics(durations);
-
- }
-
}
}
diff --git a/src/main/java/kieker/analysis/dev/OperationsDependency.java b/src/main/java/kieker/analysis/dev/OperationsDependency.java
index e3024a96277b53fa9a44fa9e43e0b958aa8d9a66..78a82a7c7f8142629938c255ae0ad319d6ccb871 100644
--- a/src/main/java/kieker/analysis/dev/OperationsDependency.java
+++ b/src/main/java/kieker/analysis/dev/OperationsDependency.java
@@ -6,6 +6,7 @@ import java.util.Map;
import java.util.Map.Entry;
import kieker.analysis.traceanalysisdomain.AggregatedOperationCall;
+import kieker.analysis.traceanalysisdomain.OperationCall;
/**
* This class represents an aggregated aggregated-trace. It connects
@@ -19,7 +20,7 @@ public class OperationsDependency {
// TODO Move to Domain package
- private final Map<String, CollectedAggrOperationCall> operations = new HashMap<>();
+ private final Map<String, AggregatedOperationCall> operations = new HashMap<>();
private final Map<String, OperationsDependencyRelation> relations = new HashMap<>();
@@ -33,9 +34,9 @@ public class OperationsDependency {
String key = call.getIdentifier();
if (!operations.containsKey(key)) {
- operations.put(key, new CollectedAggrOperationCall(call.getContainer(), call.getComponent(), call.getOperation(), 0));
+ operations.put(key, new AggregatedOperationCall(call.getContainer(), call.getComponent(), call.getOperation(), 0));
}
- operations.get(key).addBaseOperartionCall(call);
+ operations.get(key).addBaseOperationCalls(call.getBaseOperationCalls());
}
private void addRelation(final AggregatedOperationCall call) {
@@ -65,7 +66,7 @@ public class OperationsDependency {
}
}
- public Collection<CollectedAggrOperationCall> getOperations() {
+ public Collection<AggregatedOperationCall> getOperations() {
return operations.values();
}
@@ -80,15 +81,15 @@ public class OperationsDependency {
System.out.println("Operations:");
System.out.println();
- for (Entry<String, CollectedAggrOperationCall> call : operations.entrySet()) {
+ for (Entry<String, AggregatedOperationCall> call : operations.entrySet()) {
System.out.println("Key: " + call.getKey());
System.out.println("Value: " + call.getValue().getOperation());
System.out.println("Calls:");
- for (AggregatedOperationCall call2 : call.getValue().getBaseOperationCalls()) {
+ for (OperationCall call2 : call.getValue().getBaseOperationCalls()) {
- System.out.println(call2.getOperation() + ": " + call2.getCalls());
+ System.out.println(call2.getOperation());
// System.out.println(call2.getFailedCause());
}
diff --git a/src/main/java/kieker/analysis/stage/tracediagnosis/TraceAggregationComposite.java b/src/main/java/kieker/analysis/stage/tracediagnosis/TraceAggregationComposite.java
index a90dbded3e50517f1dd37b44de6e1333ab4aace7..a7d35e3452947132385e3e7e6fab093292d02fe4 100644
--- a/src/main/java/kieker/analysis/stage/tracediagnosis/TraceAggregationComposite.java
+++ b/src/main/java/kieker/analysis/stage/tracediagnosis/TraceAggregationComposite.java
@@ -16,6 +16,7 @@
package kieker.analysis.stage.tracediagnosis;
+import kieker.analysis.dev.AggregatedTraceCallsDecorator;
import kieker.analysis.traceanalysisdomain.AggregatedTrace;
import kieker.analysis.traceanalysisdomain.Trace;
@@ -32,12 +33,17 @@ public final class TraceAggregationComposite extends AbstractCompositeStage {
private final TraceAggregator aggregator;
private final AggregatedTraceStatisticsDecorator statisticsDecorator;
+ private final AggregatedTraceCallsDecorator callsDecorator;
public TraceAggregationComposite() {
this.aggregator = new TraceAggregator();
+ this.callsDecorator = new AggregatedTraceCallsDecorator();
this.statisticsDecorator = new AggregatedTraceStatisticsDecorator();
- super.connectPorts(this.aggregator.getOutputPort(), this.statisticsDecorator.getInputPort());
+ // TODO if everything is fine remove old connection
+ // super.connectPorts(this.aggregator.getOutputPort(), this.statisticsDecorator.getInputPort());
+ super.connectPorts(this.aggregator.getOutputPort(), this.callsDecorator.getInputPort());
+ super.connectPorts(this.callsDecorator.getOutputPort(), this.statisticsDecorator.getInputPort());
}
public InputPort<Trace> getInputPort() {
diff --git a/src/main/java/kieker/analysis/traceanalysisdomain/AggregatedOperationCall.java b/src/main/java/kieker/analysis/traceanalysisdomain/AggregatedOperationCall.java
index 8a3555bf091d16f1a8c186c1e94c13665c36ed9c..272a9b7ac3a9634076c42913adb27045b54dc7df 100644
--- a/src/main/java/kieker/analysis/traceanalysisdomain/AggregatedOperationCall.java
+++ b/src/main/java/kieker/analysis/traceanalysisdomain/AggregatedOperationCall.java
@@ -16,11 +16,14 @@
package kieker.analysis.traceanalysisdomain;
+import java.util.LinkedList;
+import java.util.List;
+
/**
* This class represents an aggregated operation call within this application. It adds some properties that are only available due to aggregation, like the average
* duration of all calls.
*
- * @author Nils Christian Ehmke
+ * @author Nils Christian Ehmke, Sören Henning
*/
public class AggregatedOperationCall extends AbstractOperationCall<AggregatedOperationCall> {
@@ -32,6 +35,8 @@ public class AggregatedOperationCall extends AbstractOperationCall<AggregatedOpe
private long meanDuration;
private int calls;
+ private final List<OperationCall> baseOperationCalls = new LinkedList<>();
+
public AggregatedOperationCall(final OperationCall call) {
super(call.getContainer(), call.getComponent(), call.getOperation(), call.getOrderIndex(), call.getFailedCause());
@@ -129,4 +134,16 @@ public class AggregatedOperationCall extends AbstractOperationCall<AggregatedOpe
this.calls = calls;
}
+ public List<OperationCall> getBaseOperationCalls() {
+ return baseOperationCalls;
+ }
+
+ public void addBaseOperationCall(final OperationCall baseOperationCall) {
+ baseOperationCalls.add(baseOperationCall);
+ }
+
+ public void addBaseOperationCalls(final List<OperationCall> baseOperationCalls) {
+ this.baseOperationCalls.addAll(baseOperationCalls);
+ }
+
}