transitionLogIf(es.ctx, err)
					traceFn(ILMFreeVersionDelete, nil, err)
					continue
				}

				// Remove this free version
				_, err = es.objAPI.DeleteObject(es.ctx, oi.Bucket, oi.Name, ObjectOptions{
					VersionID:        oi.VersionID,
					InclFreeVersions: true,
				})
				if err == nil {
					auditLogLifecycle(es.ctx, oi, ILMFreeVersionDelete, nil, traceFn)
				}
				if ignoreNotFoundErr(err) != nil {

				Bucket:    bucket,
				Name:      dobj.ObjectName,
				VersionID: dobj.VersionID,
			}
			traceFn := globalLifecycleSys.trace(oi)
			tags := newLifecycleAuditEvent(lcEventSrc_Scanner, lcEvent[i]).Tags()

			// Send audit for the lifecycle delete operation
			auditLogLifecycle(
				ctx,
				oi,
				ILMExpiry, tags, traceFn)

			evArgs := eventArgs{
				EventName:  event.ObjectRemovedDelete,
				BucketName: bucket,

	if err != nil {
		if isErrObjectNotFound(err) || isErrVersionNotFound(err) {
			traceFn(ILMExpiry, nil, nil)
			return false
		}
		// Assume it is still there.
		err := fmt.Errorf("DeleteObject(%s, %s): %w", obj.Bucket, obj.Name, err)
		ilmLogOnceIf(ctx, err, "non-transition-expiry"+obj.Name)
		traceFn(ILMExpiry, nil, err)
		return false
	}
	if dobj.Name == "" {
		dobj = obj
	}

		if err != nil {
			return toObjectErr(err, bucket, object)
		}
	}
	traceFn := globalLifecycleSys.trace(fi.ToObjectInfo(bucket, object, opts.Versioned || opts.VersionSuspended))

	destObj, err := genTransitionObjName(bucket)
	if err != nil {
		traceFn(ILMTransition, nil, err)
		return err
	}

	pr, pw := xioutil.WaitPipe()
	go func() {

			defer wg.Done()
			for roi := range workers[idx] {
				select {
				case <-ctx.Done():
					return
				case <-s.resyncCancelCh:
				default:
				}
				traceFn := s.trace(tgt.ResetID, fmt.Sprintf("%s/%s (%s)", opts.bucket, roi.Name, roi.VersionID))
				if roi.DeleteMarker || !roi.VersionPurgeStatus.Empty() {
					versionID := ""
					dmVersionID := ""

		if peer == nil {
			continue
		}
		peer.Trace(ctx, traceCh, traceOpts)
	}

	keepAliveTicker := time.NewTicker(time.Second)
	defer keepAliveTicker.Stop()

	for {
		select {
		case entry := <-traceCh:
			if _, err := w.Write(entry); err != nil {
				return
			}
			grid.PutByteBuffer(entry)
			if len(traceCh) == 0 {
				// Flush if nothing is queued
				xhttp.Flush(w)

    }

    public void test_stackTrace() {
        // Test that stack trace is populated
        UnsupportedSearchException exception = new UnsupportedSearchException("test message");

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

        // Verify the stack trace contains this test method
        boolean foundTestMethod = false;

        assertTrue(causeStackTrace.length > 0);

        // Stack traces should be different
        assertNotSame(mainStackTrace, causeStackTrace);
    }

    /**
     * Test printStackTrace functionality
     */
    public void test_printStackTrace() {
        CrawlerSystemException exception = new CrawlerSystemException("Print stack trace test");

        StringWriter stringWriter = new StringWriter();

        // Verify that multiple threads were processed
        assertTrue("Should process at least one thread", threadCount.get() >= 1);
        assertTrue("Should have stack trace elements", stackTraceCount.get() > 0);
        assertTrue("Should have more stack traces than threads", stackTraceCount.get() > threadCount.get());
    }

    public void test_processThreadDump_withException() {
        Consumer<String> exceptionConsumer = line -> {

//
// The passed in handler function must be a method of `objectAPIHandlers` for
// the name displayed in logs and trace to be accurate. The name is extracted
// via reflection.
//
// When **no** flags are passed, the behavior is to trace both headers and body,
// gzip the response and throttle the handler via `maxClients`. Each of these
// can be disabled via the corresponding `s3HFlag`.
//