org.hibernate.search.elasticsearch.logging.impl

## Interface Log

- All Superinterfaces:
    org.jboss.logging.BasicLogger, Log

      @MessageLogger(projectCode="HSEARCH")
      public interface Log
      extends Log

  Hibernate Search log abstraction for the Elasticsearch integration.
  Author:
    Gunnar Morling

- - ### Field Summary

    - ### Fields inherited from interface org.hibernate.search.util.logging.impl.Log

      `AVRO_SERIALIZATION_MESSAGES_START_ID, ES_BACKEND_MESSAGES_START_ID, JGROUPS_BACKEND_MESSAGES_START_ID`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `analyzerIsNotElasticsearch(IndexedTypeIdentifier entityType, String fieldName, AnalyzerReference analyzerReference)`
    `SearchException` | `analyzerNamingConflict(String remoteName)`
    `SearchException` | `analyzerNormalizerNamingConflict(String remoteName)`
    `SearchException` | `backtrackingWindowOverflow(int backtrackingLimit, int windowStartIndex, int requestedIndex)`
    `SearchException` | `cannotQueryOnEmptyPhraseQuery()`
    `SearchException` | `cannotRunEsQueryTargetingEntityIndexedWithNonEsIndexManager(IndexedTypeIdentifier entityType, String query)`
    `SearchException` | `cannotSendRangeDefinitionOrderToElasticsearchBackend()`
    `SearchException` | `cannotTransformLuceneQueryIntoEsQuery(Query query)`
    `SearchException` | `cannotUseNormalizerImpl(Class<?> analyzerType)`
    `SearchException` | `cannotUseThisSortTypeWithNullSortFieldName(SortField.Type sortType)`
    `SearchException` | `charFilterNamingConflict(String remoteName)`
    `void` | `closedIndex(Object indexName)`
    `UnsupportedOperationException` | `documentExtractorTopDocsUnsupported()`
    `SearchException` | `elasticsearch2RequestDeleteByQueryNotFound()`
    `SearchException` | `elasticsearchBulkedRequestFailed(com.google.gson.JsonObject requestMetadata, com.google.gson.JsonObject requestBody, com.google.gson.JsonObject response, Exception cause)`
    `SearchException` | `elasticsearchIndexSettingsRetrievalForValidationFailed(Exception cause)`
    `SearchException` | `elasticsearchMappingCreationFailed(Object entityType, Exception cause)`
    `SearchException` | `elasticsearchMappingRetrievalForValidationFailed(Exception cause)`
    `SearchException` | `elasticsearchRequestFailed(ElasticsearchRequest request, ElasticsearchResponse response, Exception cause)`
    `SearchException` | `elasticsearchRequestTimeout()`
    `SearchException` | `elasticsearchResponseIndicatesFailure()`
    `SearchException` | `elasticsearchSettingsUpdateFailed(Object indexName, Exception e)`
    `void` | `executedRequest(String method, String path, Map<String,String> getParameters, long timeInMs, int responseStatusCode, String responseStatusMessage)`
    `void` | `executedRequest(String method, String path, Map<String,String> getParameters, long timeInMs, int responseStatusCode, String responseStatusMessage, String requestBodyParts, String responseBody)`
    `void` | `executingElasticsearchQuery(String path, Map<String,String> parameters, String bodyParts)`
    `SearchException` | `facetingRequestHasUnsupportedType(String facetingRequestType)`
    `SearchException` | `failedToDetectElasticsearchVersion(Exception e)`
    `void` | `failedToOpenIndex(Object indexName)`
    `SearchException` | `failedToParseElasticsearchResponse(int statusCode, String statusPhrase, Exception cause)`
    `SearchException` | `fieldIsBothCompositeAndConcrete(IndexedTypeIdentifier entityType, String fieldPath)`
    `SearchException` | `filterFactoryMethodInaccessible(String implementorName, String factoryMethodName, Exception cause)`
    `SearchException` | `filterFactoryMethodReturnsUnsupportedType(String implementorName, String factoryMethodName)`
    `SearchException` | `filterHasUnsupportedType(String actualClassName)`
    `UnsupportedOperationException` | `hsQueryLuceneQueryUnsupported()`
    `SearchException` | `indexedEmbeddedPrefixBypass(IndexedTypeIdentifier entityType, String fieldPath, String expectedParent)`
    `UnsupportedOperationException` | `indexManagerReaderProviderUnsupported()`
    `SearchException` | `indexMissing(Object indexName)`
    `SearchException` | `interruptedWhileWaitingForRequestCompletion(Exception cause)`
    `SearchException` | `invalidAnalysisDefinitionJsonParameter(Class<?> factoryClass, String parameterName, String causeMessage, Exception cause)`
    `SearchException` | `invalidAnalysisDefinitionJsonStringParameter(Class<?> factoryClass, String parameterName, String causeMessage, Exception cause)`
    `SearchException` | `invalidAnalysisFactoryParameter(Class<?> factoryType, String parameter, String expectedValue, String actualValue)`
    `SearchException` | `invalidElasticsearchAnalyzerDefinition(String name)`
    `SearchException` | `invalidElasticsearchAnalyzerDefinitionProvider(String providerClassName, Exception e)`
    `SearchException` | `invalidElasticsearchCharFilterDefinition(String name)`
    `SearchException` | `invalidElasticsearchTokenFilterDefinition(String name)`
    `SearchException` | `invalidElasticsearchTokenizerDefinition(String name)`
    `IllegalArgumentException` | `invalidNullMarkerForBoolean()`
    `IllegalArgumentException` | `invalidNullMarkerForCalendarAndDate(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForDuration(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForInstant(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForLocalDate(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForLocalDateTime(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForLocalTime(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForMonthDay(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForOffsetDateTime(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForOffsetTime(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForPeriod(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForYear(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForYearMonth(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForZonedDateTime(Exception e)`
    `IllegalArgumentException` | `invalidNullMarkerForZonedTime(Exception e)`
    `SearchException` | `invalidSearchAPIPayload(Exception e)`
    `SearchException` | `negativeTimeoutValue(int timeout)`
    `SearchException` | `normalizerNamingConflict(String remoteName)`
    `void` | `openedIndex(Object indexName)`
    `SearchException` | `orchestratorShutDownBeforeSubmittingChangeset(String orchestratorName)`
    `SearchException` | `schemaUpdateFailed(Object indexName, Exception cause)`
    `ElasticsearchSchemaValidationException` | `schemaValidationFailed(String message)`
    `SearchException` | `threadInterruptedWhileSubmittingChangeset(String orchestratorName)`
    `SearchException` | `tokenFilterNamingConflict(String remoteName)`
    `SearchException` | `tokenizerNamingConflict(String remoteName)`
    `SearchException` | `unableToOverrideQueryAnalyzerWithMoreThanOneAnalyzersForSimpleQueryStringQueries(Collection<String> analyzers)`
    `void` | `unexpectedElasticsearchVersion(String name)`
    `SearchException` | `unexpectedFieldType(String fieldType, String fieldName)`
    `SearchException` | `unexpectedIndexStatus(String indexName, String expected, String actual, String timeoutAndUnit)`
    `SearchException` | `unexpectedIndexStatusString(String status)`
    `SearchException` | `unexpectedNumericEncodingType(IndexedTypeIdentifier entityType, String fieldName)`
    `SearchException` | `unsupportedAnalysisDefinitionParameterValue(Class<?> factoryClass, String parameterName, String parameterValue)`
    `SearchException` | `unsupportedAnalysisFactoryParameter(Class<?> factoryType, String parameter)`
    `SearchException` | `unsupportedAnalysisFactoryTokenizerClassNameParameter(Class<?> factoryClass, String parameterName, String tokenizerClass)`
    `SearchException` | `unsupportedAnalyzerImplementation(Class<?> luceneClass)`
    `UnsupportedOperationException` | `unsupportedBackwardTraversal(int lastRequestedIndex, int index)`
    `SearchException` | `unsupportedCharFilterFactory(Class<?> factoryType)`
    `void` | `unsupportedDynamicBoost(Class<?> boostStrategyType, IndexedTypeIdentifier entityType, String fieldPath)`
    `SearchException` | `unsupportedElasticsearchVersion(String name)`
    `UnsupportedOperationException` | `unsupportedOffsettedScrolling()`
    `SearchException` | `unsupportedProjectionOfNonJsonPrimitiveFields(com.google.gson.JsonElement value)`
    `SearchException` | `unsupportedSearchAPIPayloadAttributes(List<String> invalidAttributes)`
    `SearchException` | `unsupportedTokenFilterFactory(Class<?> factoryType)`
    `SearchException` | `unsupportedTokenizerFactory(Class<?> factoryType)`
    `void` | `usingPasswordOverHttp(String serverUris)`

    - ### Methods inherited from interface org.hibernate.search.util.logging.impl.Log

      `abstractClassesCannotInsertDocuments, ambiguousLatitudeDefinition, ambiguousLongitudeDefinition, analyzerDefinitionNamingConflict, analyzerReferenceIsNotLucene, analyzerReferenceIsNotRemote, analyzerReferenceNotInitialized, assertionFailureCannotCastToWorkerBuilderContext, assertionNotLoadingUTF8Charset, attemptToCreateFacetingRequestForUnindexedEntity, attemptToFacetOnAnalyzedField, attributeNotRecognizedNorSerializable, backendError, backendNonTransactional, beanResolverContainedInProvidedServicesException, booleanQueryWithoutClauses, cannotCreateBridgeDefinedField, cannotDeserializeField, cannotDeserializeOperation, cannotExtractCoordinateFromObject, cannotExtractValueForIdentifier, cannotFindCoordinatesNorLatLongForSpatial, cannotGetResultSizeWithCriteriaAndRestriction, cannotGuessTransactionStatus, cannotHaveTwoSpatialsWithDefaultOrSameName, cannotInitializeDirectoryProvider, cannotInstantiateClassBridgeOfType, cannotOpenIndexWriterCausePreviousError, cannotReadFieldForClass, cannotReferenceAnalyzerAndNormalizer, cannotRunLuceneQueryTargetingEntityIndexedWithNonLuceneIndexManager, cannotSerializeCustomField, cantOpenCorruptedIndex, cantQueryUnconfiguredType, cantQueryUnindexedType, classLoaderServiceContainedInProvidedServicesException, closedBlackholeBackend, closingIndexWriter, configurationPropertyCantBeEmpty, conflictingParameterDefined, containedInPointsToProvidedId, conversionFromReaderToStringNotYetImplemented, couldNotAnalyzeSortableField, couldNotCloseResource, couldNotCreateUninvertingReader, deprecatedBackendName, deprecatedConfigurationPropertyIsIgnored, detectInfiniteTypeLoopInIndexedEmbedded, directoryIsNotReadable, distanceSortRequiresSpatialField, duplicateDocumentIdFound, entityWithIdNotFound, entityWithNoShard, errorDuringFacetingIndexing, errorRollingBackTransaction, exceptionDuringFactoryMethodExecution, exceptionDuringIndexMergeOperation, exceptionOccurred, executingLuceneQuery, facetAnnotationWithoutMatchingField, factoryMethodsMustReturnAnObject, failedSlaveDirectoryProviderInitialization, failToDeserializeObject, failToSerializeObject, fieldBridgeNotAnInstanceof, fieldBridgeNotTwoWay, fieldIdCannotBeUsedInMoreLikeThis, fieldLooksBinaryButDecompressionFailed, fieldNotStoredNorTermVectorCannotBeUsedInMoreLikeThis, fieldTriesToOverrideIdFieldSettings, fileDeleteFailureIgnored, fileDoesNotExist, fileIsADirectory, fileIsNotReadable, flushIntervalNeedsToBePositive, forceRemoveOnIndexOperationViaInterception, forceSkipIndexOperationViaInterception, forceToUseDocumentExtraction, forceUpdateOnIndexOperationViaInterception, forcingReleaseIndexWriterLock, foundCurrentMarker, fullTextFilterDefinitionNamingConflict, getFieldNameCannotBeNullException, getInvalidIntegerValueException, getInvalidShardCountException, getMultipleServiceImplementationsException, getNoServiceImplementationFoundException, getNoSessionFactoryInContextException, getNullEntityManagerPassedToFullEntityManagerCreationException, getNullSessionPassedToFullTextSessionCreationException, getPropertyNameCannotBeNullException, getUnableToCreateJGroupsBackendException, getUnableToLoadShardingStrategyClassException, getUnableToNarrowFieldDescriptorException, getUnexpectedServiceStatusException, givenCriteriaObjectCannotBeApplied, idCannotBeExtracted, idHashShardingWithSingleShard, ignoringBackendOptionForIndex, illegalLuceneVersionFormat, illegalObjectRetrievedFromMessage, incompatibleProtocolVersion, incompleteEntityInfo, inconsistentFieldConfiguration, inconsistentSortableFieldConfigurationForSharedIndex, incorrectEditDistance, incorrectMessageType, indexBasePathRequiredForLockingStrategy, indexDirectoryNotFoundCreatingNewOne, indexingCompletedAndMBeanUnregistered, indexingDocumentsCompleted, indexingEntities, indexingEntitiesCompleted, indexingSpeed, indexManagerAliasResolved, indexManagerTypeRequiredToBuildFieldBridge, indexManagerUsesSerializationService, indexNamesCollisionDetected, initializedBlackholeBackend, interruptedBatchIndexing, interruptedWhileWaitingForIndexActivity, interruptedWorkError, invalidEmptyNormalizerDefinition, invalidIncludePathConfiguration, invalidLuceneAnalyzerDefinitionProvider, invalidNullMarkerForDouble, invalidNullMarkerForFloat, invalidNullMarkerForInteger, invalidNullMarkerForLong, invalidPropertyValue, invalidStringDateFieldInDocument, ioExceptionOnIndex, ioExceptionOnIndexOfEntity, ioExceptionOnIndexWriter, ioExceptionOnMultiReaderRefresh, jmsInitialContextException, jmsQueueFactoryLookupException, jmsQueueLookupException, lazyLuceneAnalyzerReferenceNotInitialized, lazyRemoteAnalyzerReferenceNotInitialized, loadingNonExistentField, lockingFailureDuringInitialization, logInfoStreamMessage, luceneBackendInitializedAsynchronously, luceneBackendInitializedSynchronously, massIndexerExceptionWhileFetchingIds, massIndexerExceptionWhileTransformingIds, massIndexerUnableToIndexInstance, massIndexerUnexpectedErrorMessage, multipleFactoryMethodsInClass, multipleMatchingFieldBridges, multipleTermsInAnalyzedSortableField, needAtLeastOneIndexedEntityType, needAtLeastOneIndexName, noCurrentMarkerInSourceDirectory, noDocumentIdFoundException, noFieldBridgeInterfaceImplementedByClassBridge, noFieldBridgeInterfaceImplementedByFieldBridge, noFieldCompatibleForMoreLikeThis, noImplementationClassInFieldBridge, noPublicNoArgConstructor, normalizerDefinitionNamingConflict, normalizerProducedMultipleTokens, noStartOrEndSpecifiedForRangeQuery, notAnIndexedType, notDeleted, nullIsInvalidIndexedType, nullIsInvalidIndexName, nullMarkerInvalidFormat, numericDateFacetForNonNumericField, numericEncodedFieldsAreTargetedWithStringQuery, numericFieldAnnotationWithoutMatchingField, numericFieldCannotBeUsedInMoreLikeThis, numericRangeQueryWithNonNumericToAndFromValues, optimizationSkippedStillBusy, parametersShouldNotBeNull, parseException, projectingFieldWithoutTwoWayFieldBridge, projectingNonStoredField, providedServicesCannotImplementStartableOrStoppable, pushedChangesOutOfTransaction, queryWithNoIndexedType, queryWithNoTermsAfterAnalysis, rangeDefinitionOrderRequestedForDiscreteFacetRequest, rangeQueryWithNullToAndFromValue, readersNotProperlyClosedInReaderProvider, readerTypeUnsupportedForInverting, recommendConfiguringLuceneVersion, remoteAnalyzerNotInitialized, requestedIndexNotDefined, requireTFIDFSimilarity, searchFactoryReferenceServiceNotFound, searchIntegratorNotInitialized, serializationProtocol, serializationProviderNotFoundException, serviceProviderNotReleased, serviceRequestedAfterReleasedAllWasCalled, severalNumericFieldAnnotationsForSameField, shuttingDownBackend, simpleQueryParserDoesNotSupportNullQueries, singleTermDeleteDisabled, skippingDirectorySynchronization, sortableFieldRefersToUndefinedField, sortableFieldWithNonNormalizerAnalyzer, sortFieldTypeUnsupported, sortRequiresIndexedField, sortTypeDoesNotMatchFieldType, sourceDirectoryNotExisting, startingSyncConsumerThread, stoppingSyncConsumerThread, stopServiceFailed, stringEncodedFieldsAreTargetedWithNumericQuery, targetedEntityTypesNotConfigured, targetedEntityTypesNotIndexed, targetedFieldNotSpatial, timedOutWaitingShutdown, timedOutWaitingShutdownOfReaderProvider, transactionNotActiveWhileProducingIdsForBatchIndexing, unableToAccessClass, unableToAccessMethod, unableToCloseJmsConnection, unableToCloseLuceneDirectory, unableToCloseLuceneIndexReader, unableToCloseSearcherDuringQuery, unableToCloseSearcherInScrollableResult, unableToCompareSourceWithDestinationDirectory, unableToConfigureTikaBridge, unableToConvertSerializableStoreToLuceneStore, unableToCreateCurrentMarker, unableToDeleteByQuery, unableToDeserializeAvroStream, unableToDetermineClassBridge, unableToDetermineCurrentInSourceDirectory, unableToGetInputStreamFromBlob, unableToGuessFieldBridge, unableToInitializeIndexManager, unableToInstantiateFieldBridge, unableToInstantiateSpatial, unableToLoadResource, unableToOpenJMSConnection, unableToParseDocument, unableToReadSerializedLuceneWorks, unableToReadTokenStream, unableToRemovePreviousMarker, unableToRetrieveNamedAnalyzer, unableToRetrieveObjectFromMessage, unableToSearchOnNullValueWithoutFieldBridge, unableToSendJMSWork, unableToSerializeInAvro, unableToSerializeLuceneWorks, unableToSetFilterParameter, unableToShutdownAsynchronousIndexingByTimeout, unableToSynchronizeSource, unableToUnregisterExistingMBean, uncoveredSortsRequested, uncoveredSortsRequestedWithUninvertingNotAllowed, unexpectedBinaryDocValuesTypeType, unexpectedNumericDocValuesTypeType, unexpectedProjectionConstant, unexpectedValueMissingFromFieldCache, unknownAttributeSerializedRepresentation, unknownDeletionQueryKeySpecified, unknownDocValuesTypeType, unknownEncodingType, unknownFieldNameForFaceting, unknownFieldNameForMoreLikeThisQuery, unknownFieldType, unknownFullTextFilter, unknownIndexingMode, unknownNumericFieldType, unknownResolution, unsupportedErrorHandlerConfigurationValueType, unsupportedFacetRangeParameter, unsupportedFieldTypeForFaceting, unsupportedNullTokenType, unsupportedParameterTypeForRangeFaceting, unsupportedTikaBridgeType, usingDeprecatedNameForRamDirectoryProvider, usingSerializationService, valueTooLargeForConversionException, version, warnSuspiciousBackendDirectoryCombination, workerException, workListShouldNeverBeEmpty`

    - ### Methods inherited from interface org.jboss.logging.BasicLogger

      `debug, debug, debug, debug, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugv, debugv, debugv, debugv, debugv, debugv, debugv, debugv, error, error, error, error, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorv, errorv, errorv, errorv, errorv, errorv, errorv, errorv, fatal, fatal, fatal, fatal, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, info, info, info, info, infof, infof, infof, infof, infof, infof, infof, infof, infov, infov, infov, infov, infov, infov, infov, infov, isDebugEnabled, isEnabled, isInfoEnabled, isTraceEnabled, log, log, log, log, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, trace, trace, trace, trace, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracev, tracev, tracev, tracev, tracev, tracev, tracev, tracev, warn, warn, warn, warn, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnv, warnv, warnv, warnv, warnv, warnv, warnv, warnv`

- - ### Method Detail

    - #### cannotRunEsQueryTargetingEntityIndexedWithNonEsIndexManager

          @Message(id=400001,
                   value="Cannot execute query \'%2$s\', as targeted entity type \'%1$s\' is not mapped to an Elasticsearch index")
          SearchException cannotRunEsQueryTargetingEntityIndexedWithNonEsIndexManager(@FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                    IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                    String query)

    - #### cannotTransformLuceneQueryIntoEsQuery

          @Message(id=400002,
                   value="Lucene query \'%1$s\' cannot be transformed into equivalent Elasticsearch query")
          SearchException cannotTransformLuceneQueryIntoEsQuery(Query query)

    - #### cannotSendRangeDefinitionOrderToElasticsearchBackend

          @Message(id=400004,
                   value="The sort order RANGE_DEFINITION_ORDER cant not be sent used with Elasticsearch")
          SearchException cannotSendRangeDefinitionOrderToElasticsearchBackend()

    - #### cannotUseThisSortTypeWithNullSortFieldName

          @Message(id=400005,
                   value="The SortType \'%1$s\' cannot be used with a null sort field name")
          SearchException cannotUseThisSortTypeWithNullSortFieldName(SortField.Type sortType)

    - #### cannotQueryOnEmptyPhraseQuery

          @Message(id=400006,
                   value="Empty phrase queries are not supported")
          SearchException cannotQueryOnEmptyPhraseQuery()

    - #### elasticsearchRequestFailed

          @Message(id=400007,
                   value="Elasticsearch request failed\nRequest:\n========\n%1$sResponse:\n=========\n%2$s")
          SearchException elasticsearchRequestFailed(@FormatWith(value=ElasticsearchRequestFormatter.class)
                                                                                                                                                                            ElasticsearchRequest request,
                                                                                                                                                                            @FormatWith(value=ElasticsearchResponseFormatter.class)
                                                                                                                                                                            ElasticsearchResponse response,
                                                                                                                                                                            @Cause
                                                                                                                                                                            Exception cause)

    - #### elasticsearchBulkedRequestFailed

          @Message(id=400008,
                   value="Elasticsearch bulked request failed\nRequest:\n========\n%1$s\n%2$sResponse:\n=========\n%3$s")
          SearchException elasticsearchBulkedRequestFailed(@FormatWith(value=ElasticsearchJsonObjectFormatter.class)
                                                                                                                                                                                               com.google.gson.JsonObject requestMetadata,
                                                                                                                                                                                               @FormatWith(value=ElasticsearchJsonObjectFormatter.class)
                                                                                                                                                                                               com.google.gson.JsonObject requestBody,
                                                                                                                                                                                               @FormatWith(value=ElasticsearchJsonObjectFormatter.class)
                                                                                                                                                                                               com.google.gson.JsonObject response,
                                                                                                                                                                                               @Cause
                                                                                                                                                                                               Exception cause)

    - #### analyzerIsNotElasticsearch

          @LogMessage(level=WARN)
           @Message(id=400009,
                   value="Field \'%2$s\' in \'%1$s\' requires an Elasticsearch analyzer reference (got \'%3$s\' instead). The analyzer will be ignored.")
          void analyzerIsNotElasticsearch(@FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                       IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                       String fieldName,
                                                                                                                                                                                                                                       AnalyzerReference analyzerReference)

    - #### elasticsearchRequestTimeout

          @Message(id=400010,
                   value="Elasticsearch connection time-out; check the cluster status, it should be \'green\'")
          SearchException elasticsearchRequestTimeout()

    - #### unsupportedProjectionOfNonJsonPrimitiveFields

          @Message(id=400011,
                   value="Projection of non-JSON-primitive field values is not supported: \'%1$s\'")
          SearchException unsupportedProjectionOfNonJsonPrimitiveFields(com.google.gson.JsonElement value)

    - #### interruptedWhileWaitingForRequestCompletion

          @Message(id=400012,
                   value="Interrupted while waiting for requests to be processed.")
          SearchException interruptedWhileWaitingForRequestCompletion(@Cause
                                                                                                                                                                    Exception cause)

    - #### filterFactoryMethodReturnsUnsupportedType

          @Message(id=400013,
                   value="@Factory method does not return a Filter class or an ElasticsearchFilter class: %1$s.%2$s")
          SearchException filterFactoryMethodReturnsUnsupportedType(String implementorName,
                                                                                                                                                                                                    String factoryMethodName)

    - #### filterFactoryMethodInaccessible

          @Message(id=400014,
                   value="Unable to access @Factory method: %1$s.%2$s")
          SearchException filterFactoryMethodInaccessible(String implementorName,
                                                                                                                                            String factoryMethodName,
                                                                                                                                            @Cause
                                                                                                                                            Exception cause)

    - #### filterHasUnsupportedType

          @Message(id=400015,
                   value="Filter implementation does not implement the Filter interface or the ElasticsearchFilter interface: %1$s")
          SearchException filterHasUnsupportedType(String actualClassName)

    - #### documentExtractorTopDocsUnsupported

          @Message(id=400016,
                   value="TopDocs not available when using Elasticsearch")
          UnsupportedOperationException documentExtractorTopDocsUnsupported()

    - #### hsQueryLuceneQueryUnsupported

          @Message(id=400017,
                   value="Cannot use Lucene query with Elasticsearch")
          UnsupportedOperationException hsQueryLuceneQueryUnsupported()

    - #### unexpectedNumericEncodingType

          @Message(id=400018,
                   value="Unexpected numeric encoding type for field \'%2$s\' on entity type \'%1$s\'. If you used a custom field bridge, make sure it implements MetadataProvidingFieldBridge and provides metadata for this field.")
          SearchException unexpectedNumericEncodingType(@FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                                                                                         IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                                                                                         String fieldName)

    - #### elasticsearchMappingCreationFailed

          @Message(id=400020,
                   value="Could not create mapping for entity type %1$s")
          SearchException elasticsearchMappingCreationFailed(Object entityType,
                                                                                                                                                 @Cause
                                                                                                                                                 Exception cause)

    - #### unexpectedFieldType

          @Message(id=400021,
                   value="Unexpected field type for field \'%2$s\': %1$s")
          SearchException unexpectedFieldType(String fieldType,
                                                                                                                                   String fieldName)

    - #### unexpectedIndexStatusString

          @Message(id=400022,
                   value="Unexpected index status string: \'%1$s\'. Specify one of \'green\', \'yellow\' or \'red\'.")
          SearchException unexpectedIndexStatusString(String status)

    - #### negativeTimeoutValue

          @Message(id=400023,
                   value="Positive timeout value expected, but it was: %1$s")
          SearchException negativeTimeoutValue(int timeout)

    - #### unexpectedIndexStatus

          @Message(id=400024,
                   value="Timed out while waiting for for index \'%1$s\' to reach status \'%2$s\'; status was still \'%3$s\' after %4$s.")
          SearchException unexpectedIndexStatus(String indexName,
                                                                                                                                                                                                     String expected,
                                                                                                                                                                                                     String actual,
                                                                                                                                                                                                     String timeoutAndUnit)

    - #### indexManagerReaderProviderUnsupported

          @Message(id=400025,
                   value="With an Elasticsearch backend it is not possible to get a ReaderProvider or an IndexReader")
          UnsupportedOperationException indexManagerReaderProviderUnsupported()

    - #### facetingRequestHasUnsupportedType

          @Message(id=400026,
                   value="Faceting request of type %1$s not supported")
          SearchException facetingRequestHasUnsupportedType(String facetingRequestType)

    - #### invalidNullMarkerForBoolean

          @Message(id=400027,
                   value="The \'indexNullAs\' property for Boolean fields must represent a Boolean (\'true\' or \'false\').")
          IllegalArgumentException invalidNullMarkerForBoolean()

    - #### invalidNullMarkerForCalendarAndDate

          @Message(id=400028,
                   value="The \'indexNullAs\' property for Calendar and Date fields must represent a date/time in ISO-8601 format (yyyy-MM-dd\'T\'HH:mm:ssZ).")
          IllegalArgumentException invalidNullMarkerForCalendarAndDate(@Cause
                                                                                                                                                                                                                                                 Exception e)

    - #### unsupportedOffsettedScrolling

          @Message(id=400029,
                   value="Cannot use an offset (\'from\', \'firstResult\') when scrolling through Elasticsearch results")
          UnsupportedOperationException unsupportedOffsettedScrolling()

    - #### unsupportedBackwardTraversal

          @Message(id=400030,
                   value="Cannot scroll backward through Elasticsearch results. Previously accessed index was %1$s, requested index is %2$s.")
          UnsupportedOperationException unsupportedBackwardTraversal(int lastRequestedIndex,
                                                                                                                                                                                                                              int index)

    - #### backtrackingWindowOverflow

          @Message(id=400031,
                   value="Cannot scroll backward more than %1$s positions through Elasticsearch results. First index still in memory is %2$s, requested index is %3$s.")
          SearchException backtrackingWindowOverflow(int backtrackingLimit,
                                                                                                                                                                                                                                        int windowStartIndex,
                                                                                                                                                                                                                                        int requestedIndex)

    - #### unsupportedDynamicBoost

          @LogMessage(level=WARN)
           @Message(id=400032,
                   value="@DynamicBoost is not supported with Elasticsearch. Ignoring boost strategy \'%1$s\' for entity \'%2$s\' (field path \'%3$s\').")
          void unsupportedDynamicBoost(Class<?> boostStrategyType,
                                                                                                                                                                                                                                     @FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                     IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                     String fieldPath)

    - #### schemaValidationFailed

          @Message(id=400033,
                   value="An Elasticsearch schema validation failed: %1$s")
          ElasticsearchSchemaValidationException schemaValidationFailed(String message)

    - #### elasticsearchMappingRetrievalForValidationFailed

          @Message(id=400034,
                   value="Could not retrieve the mappings from Elasticsearch for validation")
          SearchException elasticsearchMappingRetrievalForValidationFailed(@Cause
                                                                                                                                                                                   Exception cause)

    - #### schemaUpdateFailed

          @Message(id=400035,
                   value="Could not update mappings in index \'%1$s\'")
          SearchException schemaUpdateFailed(Object indexName,
                                                                                                                               @Cause
                                                                                                                               Exception cause)

    - #### fieldIsBothCompositeAndConcrete

          @Message(id=400036,
                   value="Mapping conflict detected for field \'%2$s\' on entity \'%1$s\'. The current mapping would require the field to be mapped to both a composite field (\'object\' datatype) and a \"concrete\" field (\'integer\', \'date\', etc.) holding a value, which Elasticsearch does not allow. If you\'re seeing this issue, you probably added both an @IndexedEmbedded annotation and a @Field (or similar) annotation on the same property: if that\'s the case, please set either @IndexedEmbedded.prefix or @Field.name to a custom value different from the default to resolve the conflict.")
          SearchException fieldIsBothCompositeAndConcrete(@FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          String fieldPath)

    - #### invalidNullMarkerForPeriod

          @Message(id=400037,
                   value="The \'indexNullAs\' property for Period fields must represent a date interval in ISO-8601 format (for instance P3Y2M1D for 3 years, 2 months and 1 day).")
          IllegalArgumentException invalidNullMarkerForPeriod(@Cause
                                                                                                                                                                                                                                                             Exception e)

    - #### invalidNullMarkerForDuration

          @Message(id=400038,
                   value="The \'indexNullAs\' property for Duration fields must represent a duration in ISO-8601 format (for instance P1DT2H3M4.007S for 1 day, 2 hours, 3 minutes, 4 seconds and 7 miliseconds).")
          IllegalArgumentException invalidNullMarkerForDuration(@Cause
                                                                                                                                                                                                                                                                                              Exception e)

    - #### invalidNullMarkerForInstant

          @Message(id=400039,
                   value="The \'indexNullAs\' property for Instant fields must represent a date/time in ISO-8601 format (yyyy-MM-dd\'T\'HH:mm:ssZ[ZZZ]).")
          IllegalArgumentException invalidNullMarkerForInstant(@Cause
                                                                                                                                                                                                                                    Exception e)

    - #### invalidNullMarkerForLocalDateTime

          @Message(id=400040,
                   value="The \'indexNullAs\' property for LocalDateTime fields must represent a local date/time in ISO-8601 format (yyyy-MM-dd\'T\'HH:mm:ss).")
          IllegalArgumentException invalidNullMarkerForLocalDateTime(@Cause
                                                                                                                                                                                                                                                Exception e)

    - #### invalidNullMarkerForLocalDate

          @Message(id=400041,
                   value="The \'indexNullAs\' property for LocalDate fields must represent a local date in ISO-8601 format (yyyy-MM-dd).")
          IllegalArgumentException invalidNullMarkerForLocalDate(@Cause
                                                                                                                                                                                                                      Exception e)

    - #### invalidNullMarkerForLocalTime

          @Message(id=400042,
                   value="The \'indexNullAs\' property for LocalTime fields must represent a local time in ISO-8601 format (HH:mm:ss).")
          IllegalArgumentException invalidNullMarkerForLocalTime(@Cause
                                                                                                                                                                                                                    Exception e)

    - #### invalidNullMarkerForOffsetDateTime

          @Message(id=400043,
                   value="The \'indexNullAs\' property for OffsetDateTime fields must represent an offset date/time in ISO-8601 format (yyyy-MM-dd\'T\'HH:mm:ssZ).")
          IllegalArgumentException invalidNullMarkerForOffsetDateTime(@Cause
                                                                                                                                                                                                                                                     Exception e)

    - #### invalidNullMarkerForOffsetTime

          @Message(id=400044,
                   value="The \'indexNullAs\' property for OffsetTime fields must represent an offset time in ISO-8601 format (HH:mm:ssZ).")
          IllegalArgumentException invalidNullMarkerForOffsetTime(@Cause
                                                                                                                                                                                                                         Exception e)

    - #### invalidNullMarkerForZonedDateTime

          @Message(id=400045,
                   value="The \'indexNullAs\' property for ZonedDateTime fields must represent a zoned date/time in ISO-8601 format (yyyy-MM-dd\'T\'HH:mm:ss[ZZZ]).")
          IllegalArgumentException invalidNullMarkerForZonedDateTime(@Cause
                                                                                                                                                                                                                                                     Exception e)

    - #### invalidNullMarkerForZonedTime

          @Message(id=400046,
                   value="The \'indexNullAs\' property for ZonedTime fields must represent a zoned time in ISO-8601 format (HH:mm:ss[ZZZ]).")
          IllegalArgumentException invalidNullMarkerForZonedTime(@Cause
                                                                                                                                                                                                                         Exception e)

    - #### invalidNullMarkerForYear

          @Message(id=400047,
                   value="The \'indexNullAs\' property for Year fields must represent a year in ISO-8601 format (for instance 2014).")
          IllegalArgumentException invalidNullMarkerForYear(@Cause
                                                                                                                                                                                                             Exception e)

    - #### invalidNullMarkerForYearMonth

          @Message(id=400048,
                   value="The \'indexNullAs\' property for YearMonth fields must represent a year/month in ISO-8601 format (yyyy-MM-dd).")
          IllegalArgumentException invalidNullMarkerForYearMonth(@Cause
                                                                                                                                                                                                                      Exception e)

    - #### invalidNullMarkerForMonthDay

          @Message(id=400049,
                   value="The \'indexNullAs\' property for MonthDay fields must represent a month/day in ISO-8601 format (--MM-dd).")
          IllegalArgumentException invalidNullMarkerForMonthDay(@Cause
                                                                                                                                                                                                                Exception e)

    - #### indexMissing

          @Message(id=400050,
                   value="The index \'%1$s\' does not exist in the Elasticsearch cluster.")
          SearchException indexMissing(Object indexName)

    - #### unsupportedSearchAPIPayloadAttributes

          @Message(id=400051,
                   value="The given payload contains unsupported attributes: %1$s. Only \'query\' is supported.")
          SearchException unsupportedSearchAPIPayloadAttributes(List<String> invalidAttributes)

    - #### invalidSearchAPIPayload

          @Message(id=400052,
                   value="The given payload is not a valid JSON object.")
          SearchException invalidSearchAPIPayload(@Cause
                                                                                                                                      Exception e)

    - #### executingElasticsearchQuery

          @LogMessage(level=DEBUG)
           @Message(id=400053,
                   value="Executing Elasticsearch query on \'%s\' with parameters \'%s\': <%s>")
          void executingElasticsearchQuery(String path,
                                                                                                                                                                                Map<String,String> parameters,
                                                                                                                                                                                String bodyParts)

    - #### indexedEmbeddedPrefixBypass

          @Message(id=400054,
                   value="Invalid field path detected for field \'%2$s\' on entity \'%1$s\': the field name is not prefixed with \'%3$s\' as it should. This probably means that the field was created with a custom field bridge which added fields with an arbitrary name, not taking the name passed as a parameter into account. This is not supported with the Elasticsearch indexing service: please only add suffixes to the name passed as a parameter to the various bridge methods and never ignore this name.")
          SearchException indexedEmbeddedPrefixBypass(@FormatWith(value=IndexedTypeIdentifierFormatter.class)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           IndexedTypeIdentifier entityType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           String fieldPath,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           String expectedParent)

    - #### tokenizerNamingConflict

          @Message(id=400055,
                   value="The same tokenizer name \'%1$s\' is assigned to multiple definitions. The tokenizer names must be unique. If you used the @TokenizerDef annotation and this name was automatically generated, you may override this name by using @TokenizerDef.name.")
          SearchException tokenizerNamingConflict(String remoteName)

    - #### charFilterNamingConflict

          @Message(id=400056,
                   value="The same char filter name \'%1$s\' is assigned to multiple definitions. The char filter names must be unique. If you used the @CharFilterDef annotation and this name was automatically generated, you may override this name by using @CharFilterDef.name.")
          SearchException charFilterNamingConflict(String remoteName)

    - #### tokenFilterNamingConflict

          @Message(id=400057,
                   value="The same token filter name \'%1$s\' is assigned to multiple definitions. The token filter names must be unique. If you used the @TokenFilterDef annotation and this name was automatically generated, you may override this name by using @TokenFilterDef.name.")
          SearchException tokenFilterNamingConflict(String remoteName)

    - #### unsupportedCharFilterFactory

          @Message(id=400058,
                   value="The char filter factory \'%1$s\' is not supported with Elasticsearch. Please only use builtin Lucene factories that have a builtin equivalent in Elasticsearch.")
          SearchException unsupportedCharFilterFactory(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                             Class<?> factoryType)

    - #### unsupportedTokenizerFactory

          @Message(id=400059,
                   value="The tokenizer factory \'%1$s\' is not supported with Elasticsearch. Please only use builtin Lucene factories that have a builtin equivalent in Elasticsearch.")
          SearchException unsupportedTokenizerFactory(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                          Class<?> factoryType)

    - #### unsupportedTokenFilterFactory

          @Message(id=400060,
                   value="The token filter factory \'%1$s\' is not supported with Elasticsearch. Please only use builtin Lucene factories that have a builtin equivalent in Elasticsearch.")
          SearchException unsupportedTokenFilterFactory(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                               Class<?> factoryType)

    - #### unsupportedAnalysisFactoryParameter

          @Message(id=400061,
                   value="The parameter \'%2$s\' is not supported for the factory \'%1$s\' with Elasticsearch.")
          SearchException unsupportedAnalysisFactoryParameter(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                         Class<?> factoryType,
                                                                                                                                                                                         String parameter)

    - #### unsupportedAnalysisFactoryTokenizerClassNameParameter

          @Message(id=400062,
                   value="The parameter \'%2$s\' for the factory \'%1$s\' refers to the class \'%3$s\', which cannot be converted to a builtin Elasticsearch tokenizer type.")
          SearchException unsupportedAnalysisFactoryTokenizerClassNameParameter(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                                         Class<?> factoryClass,
                                                                                                                                                                                                                                                                         String parameterName,
                                                                                                                                                                                                                                                                         String tokenizerClass)

    - #### unsupportedAnalysisDefinitionParameterValue

          @Message(id=400063,
                   value="The parameter \'%2$s\' for the factory \'%1$s\' has an unsupported value: \'%3$s\' is unsupported with Elasticsearch.")
          SearchException unsupportedAnalysisDefinitionParameterValue(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                  Class<?> factoryClass,
                                                                                                                                                                                                                                  String parameterName,
                                                                                                                                                                                                                                  String parameterValue)

    - #### unsupportedAnalyzerImplementation

          @Message(id=400064,
                   value="The analyzer implementation \'%1$s\' is not supported with Elasticsearch. Please only use builtin Lucene analyzers that have a builtin equivalent in Elasticsearch.")
          SearchException unsupportedAnalyzerImplementation(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                                      Class<?> luceneClass)

    - #### invalidAnalysisDefinitionJsonStringParameter

          @Message(id=400065,
                   value="The parameter \'%2$s\' for the factory \'%1$s\' could not be parsed as a JSON string: %3$s")
          SearchException invalidAnalysisDefinitionJsonStringParameter(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                        Class<?> factoryClass,
                                                                                                                                                                                                        String parameterName,
                                                                                                                                                                                                        String causeMessage,
                                                                                                                                                                                                        @Cause
                                                                                                                                                                                                        Exception cause)

    - #### invalidAnalysisDefinitionJsonParameter

          @Message(id=400066,
                   value="The parameter \'%2$s\' for the factory \'%1$s\' could not be parsed as JSON: %3$s")
          SearchException invalidAnalysisDefinitionJsonParameter(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                         Class<?> factoryClass,
                                                                                                                                                                                         String parameterName,
                                                                                                                                                                                         String causeMessage,
                                                                                                                                                                                         @Cause
                                                                                                                                                                                         Exception cause)

    - #### elasticsearchSettingsUpdateFailed

          @Message(id=400067,
                   value="Could not update settings for index \'%1$s\'")
          SearchException elasticsearchSettingsUpdateFailed(Object indexName,
                                                                                                                                               @Cause
                                                                                                                                               Exception e)

    - #### elasticsearchIndexSettingsRetrievalForValidationFailed

          @Message(id=400068,
                   value="Could not retrieve the index settings from Elasticsearch for validation")
          SearchException elasticsearchIndexSettingsRetrievalForValidationFailed(@Cause
                                                                                                                                                                                               Exception cause)

    - #### closedIndex

          @LogMessage(level=INFO)
           @Message(id=400069,
                   value="Closed Elasticsearch index \'%1$s\' automatically.")
          void closedIndex(Object indexName)

    - #### openedIndex

          @LogMessage(level=INFO)
           @Message(id=400070,
                   value="Opened Elasticsearch index \'%1$s\' automatically.")
          void openedIndex(Object indexName)

    - #### failedToOpenIndex

          @LogMessage(level=ERROR)
           @Message(id=400071,
                   value="Failed to open Elasticsearch index \'%1$s\' ; see the stack trace below.")
          void failedToOpenIndex(Object indexName)

    - #### elasticsearch2RequestDeleteByQueryNotFound

          @Message(id=400072,
                   value="DeleteByQuery request to Elasticsearch failed with 404 result code.\nPlease check that 1. you installed the delete-by-query plugin on your Elasticsearch nodes and 2. the targeted index exists")
          SearchException elasticsearch2RequestDeleteByQueryNotFound()

    - #### usingPasswordOverHttp

          @LogMessage(level=WARN)
           @Message(id=400073,
                   value="Hibernate Search will connect to Elasticsearch server \'%1$s\' with authentication over plain HTTP (not HTTPS). The password will be sent in clear text over the network.")
          void usingPasswordOverHttp(String serverUris)

    - #### analyzerNamingConflict

          @Message(id=400074,
                   value="The same analyzer name \'%1$s\' is assigned to multiple definitions. The analyzer names must be unique.")
          SearchException analyzerNamingConflict(String remoteName)

    - #### invalidElasticsearchAnalyzerDefinitionProvider

          @Message(id=400075,
                   value="Property \'hibernate.search.elasticsearch.analysis_definition_provider\' set to value \'%1$s\' is invalid. The value must be the fully-qualified name of a class with a public, no-arg constructor in your classpath. Also, the class must either implement ElasticsearchAnalyzerDefinitionProvider or expose a public, @Factory-annotated method returning a ElasticsearchAnalyzerDefinitionProvider.")
          SearchException invalidElasticsearchAnalyzerDefinitionProvider(String providerClassName,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      @Cause
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exception e)

    - #### invalidElasticsearchAnalyzerDefinition

          @Message(id=400076,
                   value="Invalid analyzer definition for name \'%1$s\'. Analyzer definitions must at least define the tokenizer.")
          SearchException invalidElasticsearchAnalyzerDefinition(String name)

    - #### invalidElasticsearchTokenizerDefinition

          @Message(id=400077,
                   value="Invalid tokenizer definition for name \'%1$s\'. Tokenizer definitions must at least define the tokenizer type.")
          SearchException invalidElasticsearchTokenizerDefinition(String name)

    - #### invalidElasticsearchCharFilterDefinition

          @Message(id=400078,
                   value="Invalid char filter definition for name \'%1$s\'. Char filter definitions must at least define the char filter type.")
          SearchException invalidElasticsearchCharFilterDefinition(String name)

    - #### invalidElasticsearchTokenFilterDefinition

          @Message(id=400079,
                   value="Invalid token filter definition for name \'%1$s\'. Token filter definitions must at least define the token filter type.")
          SearchException invalidElasticsearchTokenFilterDefinition(String name)

    - #### failedToDetectElasticsearchVersion

          @Message(id=400080,
                   value="Failed to detect the Elasticsearch version running on the cluster.")
          SearchException failedToDetectElasticsearchVersion(@Cause
                                                                                                                                                                      Exception e)

    - #### unsupportedElasticsearchVersion

          @Message(id=400081,
                   value="An unsupported Elasticsearch version runs on the Elasticsearch cluster: \'%s\'. Please refer to the documentation to know which versions are supported.")
          SearchException unsupportedElasticsearchVersion(String name)

    - #### executedRequest

          @LogMessage(level=DEBUG)
           @Message(id=400082,
                   value="Executed Elasticsearch HTTP %s request to path \'%s\' with query parameters %s in %dms. Response had status %d \'%s\'.")
          void executedRequest(String method,
                                                                                                                                                                                                                      String path,
                                                                                                                                                                                                                      Map<String,String> getParameters,
                                                                                                                                                                                                                      long timeInMs,
                                                                                                                                                                                                                      int responseStatusCode,
                                                                                                                                                                                                                      String responseStatusMessage)

    - #### unableToOverrideQueryAnalyzerWithMoreThanOneAnalyzersForSimpleQueryStringQueries

          @Message(id=400083,
                   value="For simple query string queries, Elasticsearch does not support overriding fields with more than one different analyzers: %1$s.")
          SearchException unableToOverrideQueryAnalyzerWithMoreThanOneAnalyzersForSimpleQueryStringQueries(Collection<String> analyzers)

    - #### invalidAnalysisFactoryParameter

          @Message(id=400084,
                   value="The parameter \'%2$s\' must have value \'%3$s\' for the factory \'%1$s\' with Elasticsearch. Current value \'%4$s\' is invalid.")
          SearchException invalidAnalysisFactoryParameter(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                Class<?> factoryType,
                                                                                                                                                                                                                                String parameter,
                                                                                                                                                                                                                                String expectedValue,
                                                                                                                                                                                                                                String actualValue)

    - #### unexpectedElasticsearchVersion

          @LogMessage(level=WARN)
           @Message(id=400085,
                   value="Hibernate Search may not work correctly, because an unknown Elasticsearch version runs on the Elasticsearch cluster: \'%s\'.")
          void unexpectedElasticsearchVersion(String name)

    - #### normalizerNamingConflict

          @Message(id=400086,
                   value="The same normalizer name \'%1$s\' is assigned to multiple definitions. The analyzer names must be unique.")
          SearchException normalizerNamingConflict(String remoteName)

    - #### analyzerNormalizerNamingConflict

          @Message(id=400087,
                   value="The same name \'%1$s\' is assigned to a normalizer definition and an analyzer definition. This is not possible on Elasticsearch 5.1 and below, since normalizers are translated to analyzers under the hood.")
          SearchException analyzerNormalizerNamingConflict(String remoteName)

    - #### cannotUseNormalizerImpl

          @Message(id=400088,
                   value="You cannot use @Normalizer(impl = \"%1$s\") on entities mapped to Elasticsearch: there are no built-in normalizers in Elasticsearch. Use @Normalizer(definition = \"...\") instead.")
          SearchException cannotUseNormalizerImpl(@FormatWith(value=ClassFormatter.class)
                                                                                                                                                                                                                                                                            Class<?> analyzerType)

    - #### failedToParseElasticsearchResponse

          @Message(id=400089,
                   value="Failed to parse Elasticsearch response. Status code was \'%1$d\', status phrase was \'%2$s\'.")
          SearchException failedToParseElasticsearchResponse(int statusCode,
                                                                                                                                                                                                 String statusPhrase,
                                                                                                                                                                                                 @Cause
                                                                                                                                                                                                 Exception cause)

    - #### elasticsearchResponseIndicatesFailure

          @Message(id=400090,
                   value="Elasticsearch response indicates a failure.")
          SearchException elasticsearchResponseIndicatesFailure()

    - #### threadInterruptedWhileSubmittingChangeset

          @Message(id=400091,
                   value="The thread was interrupted while a changeset was being submitted to \'%1$s\'. The changeset has been discarded.")
          SearchException threadInterruptedWhileSubmittingChangeset(String orchestratorName)

    - #### orchestratorShutDownBeforeSubmittingChangeset

          @Message(id=400092,
                   value="A changeset was submitted after Hibernate Search shutdown was requested to \'%1$s\'. The changeset has been discarded.")
          SearchException orchestratorShutDownBeforeSubmittingChangeset(String orchestratorName)

    - #### executedRequest

          @LogMessage(level=TRACE)
           @Message(id=400093,
                   value="Executed Elasticsearch HTTP %s request to path \'%s\' with query parameters %s in %dms. Response had status %d \'%s\'. Request body: <%s>. Response body: <%s>")
          void executedRequest(String method,
                                                                                                                                                                                                                                                              String path,
                                                                                                                                                                                                                                                              Map<String,String> getParameters,
                                                                                                                                                                                                                                                              long timeInMs,
                                                                                                                                                                                                                                                              int responseStatusCode,
                                                                                                                                                                                                                                                              String responseStatusMessage,
                                                                                                                                                                                                                                                              String requestBodyParts,
                                                                                                                                                                                                                                                              String responseBody)

Copyright © 2006-2017 Red Hat, Inc. All Rights Reserved