@Test public void testCopyconstructor() { final ShallowTraceBuilder builder = new ShallowTraceBuilder(IdGenerator.getNextId()); builder.setName("test"); builder.setResultType(ResultType.SUCCESS); builder.setValue("value"); builder.setStartNanos(123L); builder.setPendingNanos(234L); builder.setEndNanos(345L); builder.addAttribute("test", "value"); final ShallowTraceBuilder copied = new ShallowTraceBuilder(builder.build()); assertEquals(builder.build(), copied.build()); }
for (JsonNode traceNode : getField(rootNode, JsonTraceCodec.TRACES)) { final long traceId = getLongField(traceNode, JsonTraceCodec.TRACE_ID); final ShallowTraceBuilder shallowBuilder = new ShallowTraceBuilder(traceId); shallowBuilder.setName(name); shallowBuilder.setHidden(getBooleanField(traceNode, JsonTraceCodec.TRACE_HIDDEN)); shallowBuilder.setSystemHidden(getBooleanField(traceNode, JsonTraceCodec.TRACE_SYSTEM_HIDDEN)); shallowBuilder.setValue(getTextField(traceNode, JsonTraceCodec.TRACE_VALUE)); shallowBuilder.setStartNanos(getLongField(traceNode, JsonTraceCodec.TRACE_START_NANOS)); shallowBuilder.setPendingNanos(getLongField(traceNode, JsonTraceCodec.TRACE_PENDING_NANOS)); shallowBuilder.setEndNanos(getLongField(traceNode, JsonTraceCodec.TRACE_END_NANOS)); String key = getTextField(node, JsonTraceCodec.TRACE_ATTRIBUTE_KEY); String value = getTextField(node, JsonTraceCodec.TRACE_ATTRIBUTE_VALUE); shallowBuilder.addAttribute(key, value); shallowBuilder.setResultType(resultType); shallowBuilder.setTaskType(getTextField(traceNode, JsonTraceCodec.TRACE_TASK_TYPE)); traceMap.put(traceId, shallowBuilder.build());
public void createSurrogate() { if (_surrogate == null) { _surrogate = new ShallowTraceBuilder(IdGenerator.getNextId()); _surrogate.setName(_desc); ShallowTraceBuilder parentShallowTraceBuilder = _parent.getShallowTraceBuilder(); _surrogate.setHidden(parentShallowTraceBuilder.getHidden()); _surrogate.setSystemHidden(parentShallowTraceBuilder.getSystemHidden()); parentShallowTraceBuilder.setName("fused").setSystemHidden(true); } } }
public ShallowTraceBuilder(final ShallowTrace shallowTrace) { this(shallowTrace.getId()); setResultType(shallowTrace.getResultType()); setName(shallowTrace.getName()); setValue(shallowTrace.getValue()); setStartNanos(shallowTrace.getStartNanos()); setPendingNanos(shallowTrace.getPendingNanos()); setEndNanos(shallowTrace.getEndNanos()); setHidden(shallowTrace.getHidden()); setSystemHidden(shallowTrace.getSystemHidden()); Map<String, String> attributes = shallowTrace.getAttributes(); if (!attributes.isEmpty()) { _attributes = new HashMap<String, String>(); _attributes.putAll(attributes); } setTaskType(shallowTrace.getTaskType()); }
/** * Constructs a base task with a name and type of task * * @param name the name for this task. * @param taskType the type of the task */ public BaseTask(final String name, final String taskType) { super(Promises.settable()); _name = truncate(name); final State state = State.INIT; _shallowTraceBuilder = new ShallowTraceBuilder(_id); _shallowTraceBuilder.setName(getName()); _shallowTraceBuilder.setResultType(ResultType.UNFINISHED); if (taskType != null) { _shallowTraceBuilder.setTaskType(taskType); } _stateRef = new AtomicReference<>(state); if (ParSeqGlobalConfiguration.isCrossThreadStackTracesEnabled()) { _taskStackTraceHolder = new Throwable(); } else { _taskStackTraceHolder = null; } }
@Test public void testUninishedWithValue() { final ShallowTraceBuilder builder = new ShallowTraceBuilder(IdGenerator.getNextId()); builder.setName("test"); builder.setResultType(ResultType.UNFINISHED); builder.setValue("non-null-value"); try { builder.build(); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException e) { // Expected case } }
@Test public void testAddRelationship() { final ShallowTraceBuilder trace1 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task1").setResultType(ResultType.UNFINISHED); final ShallowTraceBuilder trace2 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task2").setResultType(ResultType.UNFINISHED); final TraceBuilder builder = new TraceBuilder(1024, "test", 0L); builder.addRelationship(Relationship.SUCCESSOR_OF, trace1, trace2); Trace trace = builder.build(); assertEquals(trace1.build(), trace.getTraceMap().get(trace1.getId())); assertEquals(trace2.build(), trace.getTraceMap().get(trace2.getId())); assertEquals(1, trace.getRelationships().size()); assertTrue(trace.getRelationships() .contains(new TraceRelationship(trace1, trace2, Relationship.SUCCESSOR_OF))); }
/** * A helper for creating task wrapper with associated retry policy. * * @param name A name of the task that needs to be retried. * @param policy Retry policy that will control this task's behavior. * @param taskFunction A task generator function. It will receive a zero-based attempt number as a parameter. * @param <U> Type of a task result. */ public static <U> Task<U> withRetryPolicy(String name, RetryPolicy policy, Function1<Integer, Task<U>> taskFunction) { RetriableTask<U> retriableTask = new RetriableTask<>(name, policy, taskFunction); Task<U> retryTaskWrapper = Task.async(name + " retriableTask", retriableTask::run); retryTaskWrapper.getShallowTraceBuilder().setTaskType(TaskType.WITH_RETRY.getName()); return retryTaskWrapper; }
/** Create a wrapped task with associated recovery task that will retry if necessary. */ private Task<T> wrap(int attempt) { Task<T> retryTask = Task.async(_policy.getName() + ", attempt " + attempt, context -> { final SettablePromise<T> result = Promises.settable(); Task<T> task = _taskFunction.apply(attempt); final Task<T> recovery = Task.async(_name + " recovery", recoveryContext -> { final SettablePromise<T> recoveryResult = Promises.settable(); if (task.isFailed()) { // Failed task will cause retry to be scheduled. ErrorClassification errorClassification = _policy.getErrorClassifier().apply(task.getError()); retry(attempt + 1, task.getError(), errorClassification, recoveryContext, recoveryResult); } else { recoveryResult.done(task.get()); } return recoveryResult; }); // Recovery task should run immediately after the original task to process its error. recovery.setPriority(Priority.MAX_PRIORITY); recovery.getShallowTraceBuilder().setSystemHidden(true); Promises.propagateResult(recovery, result); context.after(task).run(recovery); context.run(task); return result; }); retryTask.getShallowTraceBuilder().setTaskType(TaskType.RETRY.getName()); return retryTask; }
@Test public void testRelationshipRetention() { final TraceBuilder builder = new TraceBuilder(4096, "test", 0L); List<TraceRelationship> rels = new ArrayList<TraceRelationship>(); for (int i = 0; i < 4096; i++) { final ShallowTraceBuilder trace1 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task1").setResultType(ResultType.UNFINISHED); final ShallowTraceBuilder trace2 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task2").setResultType(ResultType.UNFINISHED); builder.addRelationship(Relationship.SUCCESSOR_OF, trace1, trace2); rels.add(new TraceRelationship(trace1, trace2, Relationship.SUCCESSOR_OF)); } for (int i = 0; i < 4096 * 10; i++) { final ShallowTraceBuilder trace1 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task1").setResultType(ResultType.UNFINISHED); final ShallowTraceBuilder trace2 = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("task2").setResultType(ResultType.UNFINISHED); builder.addRelationship(Relationship.SUCCESSOR_OF, trace1, trace2); } Trace trace = builder.build(); assertEquals(rels.size(), trace.getRelationships().size()); for (TraceRelationship rel : rels) { assertTrue(trace.getRelationships().contains(rel)); } }
@Override public ShallowTraceBuilder getShallowTraceBuilder() { return new ShallowTraceBuilder(0L); }
protected SystemHiddenTask(String name) { super(name); _shallowTraceBuilder.setSystemHidden(true); } }
@Override public ShallowTrace getShallowTrace() { _shallowTraceBuilder.setHidden(true); return super.getShallowTrace(); } };
@Override public ShallowTrace getShallowTrace() { return _shallowTraceBuilder.build(); }
protected void markTaskPending() { _shallowTraceBuilder.setPendingNanos(System.nanoTime()); }
public ShallowTraceBuilder(final ShallowTrace shallowTrace) { this(shallowTrace.getId()); setResultType(shallowTrace.getResultType()); setName(shallowTrace.getName()); setValue(shallowTrace.getValue()); setStartNanos(shallowTrace.getStartNanos()); setPendingNanos(shallowTrace.getPendingNanos()); setEndNanos(shallowTrace.getEndNanos()); setHidden(shallowTrace.getHidden()); setSystemHidden(shallowTrace.getSystemHidden()); Map<String, String> attributes = shallowTrace.getAttributes(); if (!attributes.isEmpty()) { _attributes = new HashMap<String, String>(); _attributes.putAll(attributes); } setTaskType(shallowTrace.getTaskType()); }
@Override protected Promise<? extends T> run(final Context context) throws Throwable { final SettablePromise<T> result = Promises.settable(); String baseName = getName(); if (_asyncTask == null) { /* There is no async predecessor, run propagation immediately */ FusionTraceContext traceContext = new FusionTraceContext(context, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, result); } else { /* There is async predecessor, need to run it first PropagationTask will actually run propagation */ final Task<T> propagationTask = Task.async(baseName, ctx -> { final SettablePromise<T> fusionResult = Promises.settable(); FusionTraceContext traceContext = new FusionTraceContext(ctx, FusionTask.this.getShallowTraceBuilder(), baseName); propagate(traceContext, fusionResult); return fusionResult; }); propagationTask.getShallowTraceBuilder() .setHidden(_shallowTraceBuilder.getHidden()) .setSystemHidden(_shallowTraceBuilder.getSystemHidden()); _shallowTraceBuilder.setName("async fused"); _shallowTraceBuilder.setSystemHidden(true); context.after(_asyncTask).run(propagationTask); context.run(_asyncTask); Promises.propagateResult(propagationTask, result); } return result; } }
@Test public void testReversibleUnstartedTrace() throws IOException { final ShallowTraceBuilder test = new ShallowTraceBuilder(IdGenerator.getNextId()).setName("test").setResultType(ResultType.UNFINISHED) .setTaskType(TaskType.FUSION.getName()); final Trace trace = Trace.single(test.build(), "test", 0L); assertReversible(trace); }