entity.setConfigId(crawlingConfig.getConfigId());
            }
            return entity;
        });

        failureUrl.setErrorName(errorName);
        failureUrl.setErrorLog(getStackTrace(e));
        failureUrl.setLastAccessTime(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
        failureUrl.setThreadName(Thread.currentThread().getName());

        bhv.insertOrUpdate(failureUrl, op -> {

  virtual void SetCancellationManager(
      CancellationManager* cancellation_manager) = 0;

  // Returns the stack trace set by `SetStackTrace` if exists.
  virtual absl::optional<ManagedStackTrace> GetStackTrace() = 0;

  virtual void SetStepId(int64_t step_id) = 0;

  // For LLVM style RTTI.
  static bool classof(const AbstractOperation* ptr) {
    return ptr->getKind() == kEager || ptr->getKind() == kTfrt;
  }

        this.fileSuffix = fileSuffix;

        initializeCleanupMonitoring();
    }

    private void initializeCleanupMonitoring() {
        callerInfo = new NullPointerException().getStackTrace()[2];

        Runnable warning = this::maybeWarnAboutCleanUp;

        cleanupWarning = new Thread(warning);

        Runtime.getRuntime().addShutdownHook(cleanupWarning);
    }

        }

        if (track && this.traceResource) {
            synchronized (this.acquires) {
                this.acquires.add(truncateTrace(Thread.currentThread().getStackTrace()));
            }
        }

        if (usage == 1) {
            synchronized (this) {
                if (this.sessionAcquired.compareAndSet(false, true)) {

      fn_name, kDebugGroupOpStacktrace, "initial", &fn_body->graph);

  tensorflow::StackTracesMap stack_traces;
  for (const Node* n : fn_body->graph.nodes()) {
    stack_traces[n->name()] = n->GetStackTrace();
  }

  TF_Function* tf_function = new TF_Function();
  tf_function->record = new tensorflow::FunctionRecord(
      std::move(fdef), std::move(stack_traces), false);

  return tf_function;
}

            this.phantomRef = new PhantomReference<>(resource, queue);
            this.creationTime = System.currentTimeMillis();
            this.allocationStackTrace = Thread.currentThread().getStackTrace();
            this.closed = false;
        }

        boolean isAlive() {
            return resourceRef.get() != null && !closed;
        }

        long getAge() {

        return String.format("[%s] %s: %s", errorCode.name(), errorCode.getDescription(), message);
    }

    private String extractOperationName() {
        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
        for (StackTraceElement element : stack) {
            String className = element.getClassName();
            if (className.startsWith("jcifs.smb") && !className.contains("Exception")) {

            LockGraphNode.class.getName());

    ExampleStackTrace(LockGraphNode node1, LockGraphNode node2) {
      super(node1.getLockName() + " -> " + node2.getLockName());
      StackTraceElement[] origStackTrace = getStackTrace();
      for (int i = 0, n = origStackTrace.length; i < n; i++) {
        if (WithExplicitOrdering.class.getName().equals(origStackTrace[i].getClassName())) {

        ResultOffsetExceededException exception = new ResultOffsetExceededException(message);

        assertEquals(message, exception.getMessage());
        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);
        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withNullMessage() {
        // Test with null message

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify the stack trace contains this test method
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {
            if (element.getMethodName().equals("test_stackTrace")) {