S.Logger.Warn(ctx, s, i...)
}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

func (S Tracer) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
	S.Logger.Trace(ctx, begin, fc, err)
	S.Test(ctx, begin, fc, err)

        });
        return failureUrl;
    }

    /**
     * Extracts and returns the stack trace from a throwable as a string.
     * The stack trace is abbreviated if it exceeds the configured maximum length.
     *
     * @param t the throwable to extract the stack trace from
     * @return the stack trace as a string, or empty string if extraction fails
     */
    private String getStackTrace(final Throwable t) {

    return stringWriter.toString();
  }

  /**
   * Returns the stack trace of {@code throwable}, possibly providing slower iteration over the full
   * trace but faster iteration over parts of the trace. Here, "slower" and "faster" are defined in
   * comparison to the normal way to access the stack trace, {@link Throwable#getStackTrace()

                resp = new NtTransNotifyChangeResponse(th.getConfig());
            }

            if (log.isTraceEnabled()) {
                log.trace("Sending NtTransNotifyChange for " + this.handle);
            }
            try {
                resp = th.send(req, resp, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);
            } catch (final SmbException e) {

        // Test protected constructor with writable stack trace
        String message = "Test with writable stack trace";
        TestFessSystemException exception = new TestFessSystemException(message, true, true);

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());

        // Stack trace should be populated
        assertTrue(exception.getStackTrace().length > 0);

     * @param error the error that caused this log
     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error the error that caused this log
     */
    void debug(Throwable error);

    void debug(Supplier<String> content);

    }

    @Test
    @DisplayName("Test stack trace inclusion")
    void testStackTraceInclusion() {
        logger.setIncludeStackTrace(true);

        Map<String, Object> context = new HashMap<>();
        context.put("error", "Test error");

        logger.logSecurityViolation("Test violation with stack trace", context);

        logger.setIncludeStackTrace(false);

        assertSame(root, ex.getRootCause());
    }

    /**
     * Verify that {@link #toString()} includes a stack trace when a root cause
     * is present.
     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);

        this.macSigningKey = macSigningKey;
        this.signSequence = initialSequence;
        this.bypass = bypass;

        if (log.isTraceEnabled()) {
            log.trace("macSigningKey:");
            log.trace(Hexdump.toHexString(macSigningKey, 0, macSigningKey.length));
        }
    }

    /**
     * This constructor used to instance a SigningDigest object for

                    if (log.isTraceEnabled()) {
                        log.trace(response.toString());
                        log.trace(Hexdump.toHexString(this.rcv_buf, 0, this.in.getLength()));
                    }

                    response.notify();
                }
            }
        } catch (final SocketTimeoutException ste) {
            log.trace("Socket timeout", ste);
        } catch (final Exception ex) {