Requests that the call tree should not be added to the current {@link Span}

@param reason the reason why the call tree should be excluded (debug message)
@return <code>this</code> for chaining
199169
public PostExecutionInterceptorContext excludeCallTree(String reason) {
		if (!mustPreserveCallTree) {
			logger.debug("Excluding call tree because {}", reason);
			excludeCallTree = true;
		}
		return this;
	}
284594
@Override
    public void part(String reason) {
        Message partMessage = new Message(MessageType.PART, this.channelName, reason);
        this.client.getConnection().send(partMessage);
        this.joined = new CountDownLatch(1);
    }
1046874
public Exclude<ExceptionClassFilter<T>> getOrCreateExclude()
   {
      List<Node> nodeList = childNode.get("exclude");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ExcludeImpl<ExceptionClassFilter<T>>(this, "exclude", childNode, nodeList.get(0));
      }
      return createExclude();
   }
186495
public CallOptions withoutWaitForReady() {
    CallOptions newOptions = new CallOptions(this);
    newOptions.waitForReady = Boolean.FALSE;
    return newOptions;
  }
213672
public void onRootStopwatchStop(CallTree callTree, Split split) {
		callTreeLogTemplate.log(split, callTree);
		if (logThreshold != null && split.runningFor() > logThreshold) {
			split.getStopwatch().setAttribute(ATTR_NAME_LAST, callTree);
		}
		removeCallTree();
	}
122460
public synchronized void onRequestFailed(String reason) {
		allRequestsTracker.onRequestFailed(reason);
		recentRequestsTracker.onRequestFailed(reason);
		meter.mark();
	}
1214504
public boolean doInnerCallback(ModificationQueue modificationQueue, SecurityContext securityContext, ErrorBuffer errorBuffer) throws FrameworkException {

		// check for modification propagation along the relationships
		if ((status & STATE_PROPAGATING_MODIFICATION) == STATE_PROPAGATING_MODIFICATION && object instanceof AbstractNode) {

			Set<AbstractNode> nodes = ((AbstractNode)object).getNodesForModificationPropagation();
			if (nodes != null) {

				for (AbstractNode node : nodes) {

					modificationQueue.propagatedModification(node);
				}
			}

		}

		// examine only the last 4 bits here
		switch (status & 0x000f) {

			case 15:
			case 14:
			case 13:
			case 12:
			case 11:
			case 10:
			case  9:
			case  8: // since all values >= 8 mean that the object was passively deleted, no action has to be taken
				 // (no callback for passive deletion!)
				break;

			case 7:	// created, modified, deleted, poor guy => no callback
				break;

			case 6: // created, modified => only creation callback will be called
				object.onCreation(securityContext, errorBuffer);
				break;

			case 5: // created, deleted => no callback
				break;

			case 4: // created => creation callback
				object.onCreation(securityContext, errorBuffer);
				break;

			case 3: // modified, deleted => deletion callback
				object.onDeletion(securityContext, errorBuffer, removedProperties);
				break;

			case 2: // modified => modification callback
				object.onModification(securityContext, errorBuffer, modificationQueue);
				break;

			case 1: // deleted => deletion callback
				object.onDeletion(securityContext, errorBuffer, removedProperties);
				break;

			case 0:	// no action, no callback
				break;

			default:
				break;
		}

		// mark as finished
		modified = false;

		return !errorBuffer.hasError();
	}
669014
@Override
    public void quit(String reason) {
        if (!connected) {
            throw new NotConnectedException();
        }

        Message quit = new Message(MessageType.QUIT, reason);
        ChannelFuture future = connection.send(quit);

        /* Wait for message to be sent and then close the underlying connection */
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                connection.close();
            }
        });
    }
256904
protected Object executeAroundMessageReceive(ProceedingJoinPoint call) throws Throwable {
    final Object result;
    final Object[] args = call.getArgs();
    final Message message = getMessageArgument(args);
    if (message == null) {
      logger.debug("Ignoring execution around {}. Message argument not found.", call);
      result = call.proceed();
    } else {
      spanManager.beforeHandle(message);
      try {
        result = call.proceed();
        spanManager.afterHandle(null);

        return result;
      } catch (Exception e) {
        spanManager.afterHandle(e);
        throw e;
      }
    }
    return result;
  }
251219
public CallTreeNode onStopwatchStart(Split split) {
		final String name = split.getStopwatch().getName();
		CallTreeNode currentNode;
		if (callStack.isEmpty()) {
			// Root tree node
			rootNode = new CallTreeNode(name);
			currentNode = rootNode;
			onRootStopwatchStart(currentNode, split);
		} else {
			// Child node
			currentNode = callStack.getLast().getOrAddChild(name);
		}
		callStack.addLast(currentNode);
		return currentNode;
	}
411332
public static Context withValue(Context context, @javax.annotation.Nullable Span span) {
    return Utils.checkNotNull(context, "context").withValue(CONTEXT_SPAN_KEY, span);
  }
1214493
public void cancel(Exception reason) {
        // IMPROVEMENT: need to rework how syncs on the future.complete() work. We really should be
        // syncing here, so we don't do the channel.cancel if the request is processing
        // future.complete() on another thread at the same time. Should just do a quick
        // sync, check the future.complete flag, then process only if !complete. That will
        // also mean we can remove a bunch of redundant checks for complete, but we need to check all
        // the paths carefully.
        if (this.channel == null) {
            return;
        }
        synchronized (this.completedSemaphore) {
            if (!this.completed) {
                try {
                    // this ends up calling future.completed()
                    this.channel.cancel(this, reason);
                } catch (Exception e) {
                    // Simply swallow the exception
                } // end try

            } else {
                if (this.channel.readFuture != null) {
                    this.channel.readFuture.setCancelInProgress(0);
                }
                if (this.channel.writeFuture != null) {
                    this.channel.writeFuture.setCancelInProgress(0);
                }
            }
        }
    }
331360
@Deactivate
    protected void deactivate(int reason) {
        final String methodName = "deactivate";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, "Entry Count: " + ++JDBCMBeanRuntime.counterDeactivate);
        if (trace && tc.isEventEnabled())
            Tr.event(tc, className + methodName + ", reason=" + reason);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, "Normal Exit");
    }
1052966
@Deactivate
    protected void deactivate(int reason) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "File monitor service deactivated", "reason=" + reason, fileMonitors);
        }

        for (Map.Entry<ServiceReference<FileMonitor>, MonitorHolder> entry : fileMonitors.entrySet()) {
            entry.getValue().destroy();
        }
        fileMonitors.clear();
        this.cContext = null;
    }
753258
public boolean removeNode(int x, ICause cause) throws ContradictionException {
		assert cause != null;
		assert (x >= 0 && x < n);
		if (LB.getNodes().contains(x)) {
			this.contradiction(cause, "remove mandatory node");
			return true;
		} else if (!UB.getNodes().contains(x)) {
			return false;
		}
		ISet nei = UB.getSuccOrNeighOf(x);
		for (int i : nei) {
			removeArc(x, i, cause);
		}
		nei = UB.getPredOrNeighOf(x);
		for (int i : nei) {
			removeArc(i, x, cause);
		}
		if (UB.removeNode(x)) {
			if (reactOnModification) {
				delta.add(x, GraphDelta.NR, cause);
			}
			GraphEventType e = GraphEventType.REMOVE_NODE;
			notifyPropagators(e, cause);
			return true;
		}
		return false;
	}
883629
public T validationCallback(ValidationCallback callback) {
        if (callback instanceof ApplicationContextAware) {
            ((ApplicationContextAware) callback).setApplicationContext(applicationContext);
        }

        getAction().setValidationCallback(callback);
        return self;
    }
111981
protected void triggerSessionClosed(String reason) {
        //        for (ContentNegotiator contentNegotiator : contentNegotiators) {
        //
        //            contentNegotiator.stopJingleMediaSession();
        //
        //            for (TransportCandidate candidate : contentNegotiator.getTransportNegotiator().getOfferedCandidates())
        //                candidate.removeCandidateEcho();
        //        }

        List<JingleListener> listeners = getListenersList();
        for (JingleListener li : listeners) {
            if (li instanceof JingleSessionListener) {
                JingleSessionListener sli = (JingleSessionListener) li;
                sli.sessionClosed(reason, this);
            }
        }
        close();
    }