try {
                relatedContentService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

                throw new CrawlingAccessException("[" + e.status() + "] Failed to insert " + id, e);
            }
            throw new OpenSearchAccessException("[" + e.status() + "] Failed to insert " + id, e);
        } catch (final Exception e) {
            throw new OpenSearchAccessException("Failed to insert " + id, e);
        }
    }

    /**

            File file = null;
            try {
                file = new File(new URI(filePath));
            } catch (final URISyntaxException e) {
                logger.warn("Failed to parse file URI: uri={}, filePath={}", uri, filePath, e);
            }

            if (file == null) {
                responseData.setHttpStatusCode(Constants.NOT_FOUND_STATUS_CODE);

        this(5, 10, 100, Duration.ofMinutes(30), Duration.ofMinutes(5));
    }

    /**
     * Create rate limiter with custom settings
     *
     * @param maxAttemptsPerAccount max failed attempts per account before lockout
     * @param maxAttemptsPerIp max attempts from single IP
     * @param maxGlobalAttemptsPerMinute max global attempts per minute
     * @param lockoutDuration duration to lock out account/IP

                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
                ComponentUtil.getKeyMatchHelper().update();
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Failed to apply interval control rules", e);
            }
        }

        try {
            super.delayForWaitingNewUrl();
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to execute parent delay logic", e);
            }
        }
    }

        channelInfo.setState(ChannelState.ACTIVE);
        int activeScore = channelInfo.getScore();
        assertTrue(activeScore < baseScore);

        // Failed channel should have zero score
        channelInfo.setState(ChannelState.FAILED);
        assertEquals(0, channelInfo.getScore());

        // Primary channel should have higher score
        channelInfo.setState(ChannelState.ESTABLISHED);

                logger.info("User {} completed successfully: username={}, id={}", isUpdate ? "update" : "create", username, user.getId());
            }
        } catch (final Exception e) {
            logger.warn("Failed to {} user: username={}, id={}, error={}", isUpdate ? "update" : "create", username, user.getId(),
                    e.getMessage(), e);
            throw e;
        }
    }

    /**

 * and the implementation should respond with a new request that sets the "Authorization" header.
 *
 * ```java
 * if (response.request().header("Authorization") != null) {
 *   return null; // Give up, we've already failed to authenticate.
 * }
 *
 * String credential = Credentials.basic(...)
 * return response.request().newBuilder()
 *     .header("Authorization", credential)
 *     .build();
 * ```
 *

        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter: sessionId={}", sid, e);
        }

        try {
            // clear queue
            urlQueueService.clearCache();
            urlQueueService.delete(sid);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlQueue: sessionId={}", sid, e);
        }

        try {