try {
            urlFilterService.delete(sessionId);
        } catch (final Exception e) {
            logger.warn("Failed to delete url filters: {}", sessionId, e);
        }
        try {
            urlQueueService.delete(sessionId);
        } catch (final Exception e) {
            logger.warn("Failed to delete url queues: {}", sessionId, e);
        }
        try {
            dataService.delete(sessionId);

		tid         TargetID
		region      string
		expectedARN ARN
	}{
		{tid, "", ARN{TargetID: tid, region: ""}},
		{tid, "us-east-1", ARN{TargetID: tid, region: "us-east-1"}},
	}

	for i, testCase := range testCases {
		arn := testCase.tid.ToARN(testCase.region)

		if arn != testCase.expectedARN {
			t.Fatalf("test %v: ARN: expected: %v, got: %v", i+1, testCase.expectedARN, arn)
		}
	}
}

        final FileAuthentication fileAuth = getFileAuthentication(body).map(entity -> {
            try {
                fileAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

        final WebAuthentication webAuth = getWebAuthentication(body).map(entity -> {
            try {
                webAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

                    }
                } else {
                    logger.warn("Failed to send {} to {}. HTTP Status is {}. {}", body, url, response.getHttpStatusCode(),
                            response.getContentAsString());
                }
            } catch (final IOException e) {
                logger.warn("Failed to send {} to {}.", body, url, e);
            }
        }));
    }

			rs.set(ri.Arn, ri.Size, 0, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Completed:
		if ri.OpType.IsDataReplication() {
			rs.set(ri.Arn, ri.Size, ri.Duration, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Failed:
		if ri.OpType.IsDataReplication() && prevStatus == replication.Pending {

        final WebConfig webConfig = getWebConfig(body).map(entity -> {
            try {
                webConfigService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

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

isInfoEnabled(); public abstract void info(CharSequence); public abstract void info(CharSequence, Throwable); public abstract void info(Throwable); public abstract boolean isWarnEnabled(); public abstract void warn(CharSequence); public abstract void warn(CharSequence, Throwable); public abstract void warn(Throwable); public abstract boolean isErrorEnabled(); public abstract void error(CharSequence); public abstract void error(CharSequence, Throwable); public abstract void error(Throwable); } org/apache/...

                        if (!errors.isEmpty()) {
                            logger.warn("{}", errors.stream().collect(Collectors.joining(", ")));
                            if (auth.isDebugActive() && StringUtil.isNotBlank(auth.getLastErrorReason())) {
                                logger.warn("Authentication Failure: {} - Reason: {}", errors.stream().collect(Collectors.joining(", ")),