Interface LogAnalyticsAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    LogAnalyticsAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20200601")
    public interface LogAnalyticsAsync
    extends AutoCloseable
    The LogAnalytics API for the LogAnalytics service.
    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.
      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)
      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.
      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
      • addEntityAssociation

        Future<AddEntityAssociationResponse> addEntityAssociation​(AddEntityAssociationRequest request,
                                                                  AsyncHandler<AddEntityAssociationRequest,​AddEntityAssociationResponse> handler)
        Adds association between input source log analytics entity and one or more existing destination entities.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • addSourceEventTypes

        Future<AddSourceEventTypesResponse> addSourceEventTypes​(AddSourceEventTypesRequest request,
                                                                AsyncHandler<AddSourceEventTypesRequest,​AddSourceEventTypesResponse> handler)
        Add one or more event types to a source.

        An event type and version can be enabled only on one source.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • appendLookupData

        Future<AppendLookupDataResponse> appendLookupData​(AppendLookupDataRequest request,
                                                          AsyncHandler<AppendLookupDataRequest,​AppendLookupDataResponse> handler)
        Appends data to the lookup content.

        The csv file containing the content to be appended is passed in as binary data in the request.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • assignEncryptionKey

        Future<AssignEncryptionKeyResponse> assignEncryptionKey​(AssignEncryptionKeyRequest request,
                                                                AsyncHandler<AssignEncryptionKeyRequest,​AssignEncryptionKeyResponse> handler)
        This API submits a work request to assign customer encryption key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • batchGetBasicInfo

        Future<BatchGetBasicInfoResponse> batchGetBasicInfo​(BatchGetBasicInfoRequest request,
                                                            AsyncHandler<BatchGetBasicInfoRequest,​BatchGetBasicInfoResponse> handler)
        Lists basic information about a specified set of labels in batch.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • cancelQueryWorkRequest

        Future<CancelQueryWorkRequestResponse> cancelQueryWorkRequest​(CancelQueryWorkRequestRequest request,
                                                                      AsyncHandler<CancelQueryWorkRequestRequest,​CancelQueryWorkRequestResponse> handler)
        Cancel/Remove query job work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • clean

        Future<CleanResponse> clean​(CleanRequest request,
                                    AsyncHandler<CleanRequest,​CleanResponse> handler)
        Clean accumulated acceleration data stored for the accelerated saved search.

        The ScheduledTask taskType must be ACCELERATION.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • compareContent

        Future<CompareContentResponse> compareContent​(CompareContentRequest request,
                                                      AsyncHandler<CompareContentRequest,​CompareContentResponse> handler)
        Returns the difference between the two input payloads, including intraline differences.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createIngestTimeRule

        Future<CreateIngestTimeRuleResponse> createIngestTimeRule​(CreateIngestTimeRuleRequest request,
                                                                  AsyncHandler<CreateIngestTimeRuleRequest,​CreateIngestTimeRuleResponse> handler)
        Creates a new ingest time rule in the specified compartment.

        You may also specify optional information such as description, defined tags, and free-form tags.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createLogAnalyticsEmBridge

        Future<CreateLogAnalyticsEmBridgeResponse> createLogAnalyticsEmBridge​(CreateLogAnalyticsEmBridgeRequest request,
                                                                              AsyncHandler<CreateLogAnalyticsEmBridgeRequest,​CreateLogAnalyticsEmBridgeResponse> handler)
        Add configuration for enterprise manager bridge.

        Enterprise manager bridge is used to automatically add selected entities from enterprise manager cloud control. A corresponding OCI bridge configuration is required in enterprise manager.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createLogAnalyticsLogGroup

        Future<CreateLogAnalyticsLogGroupResponse> createLogAnalyticsLogGroup​(CreateLogAnalyticsLogGroupRequest request,
                                                                              AsyncHandler<CreateLogAnalyticsLogGroupRequest,​CreateLogAnalyticsLogGroupResponse> handler)
        Creates a new log group in the specified compartment with the input display name.

        You may also specify optional information such as description, defined tags, and free-form tags.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createScheduledTask

        Future<CreateScheduledTaskResponse> createScheduledTask​(CreateScheduledTaskRequest request,
                                                                AsyncHandler<CreateScheduledTaskRequest,​CreateScheduledTaskResponse> handler)
        Schedule a task as specified and return task info.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteAssociations

        Future<DeleteAssociationsResponse> deleteAssociations​(DeleteAssociationsRequest request,
                                                              AsyncHandler<DeleteAssociationsRequest,​DeleteAssociationsResponse> handler)
        Deletes the associations between the sources and entities specified.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteField

        Future<DeleteFieldResponse> deleteField​(DeleteFieldRequest request,
                                                AsyncHandler<DeleteFieldRequest,​DeleteFieldResponse> handler)
        Deletes field with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteIngestTimeRule

        Future<DeleteIngestTimeRuleResponse> deleteIngestTimeRule​(DeleteIngestTimeRuleRequest request,
                                                                  AsyncHandler<DeleteIngestTimeRuleRequest,​DeleteIngestTimeRuleResponse> handler)
        Deletes the specified ingest time rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteLabel

        Future<DeleteLabelResponse> deleteLabel​(DeleteLabelRequest request,
                                                AsyncHandler<DeleteLabelRequest,​DeleteLabelResponse> handler)
        Deletes label with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteLogAnalyticsLogGroup

        Future<DeleteLogAnalyticsLogGroupResponse> deleteLogAnalyticsLogGroup​(DeleteLogAnalyticsLogGroupRequest request,
                                                                              AsyncHandler<DeleteLogAnalyticsLogGroupRequest,​DeleteLogAnalyticsLogGroupResponse> handler)
        Deletes the specified log group.

        The log group cannot be part of an active association or have an active upload.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteLookup

        Future<DeleteLookupResponse> deleteLookup​(DeleteLookupRequest request,
                                                  AsyncHandler<DeleteLookupRequest,​DeleteLookupResponse> handler)
        Deletes lookup with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteParser

        Future<DeleteParserResponse> deleteParser​(DeleteParserRequest request,
                                                  AsyncHandler<DeleteParserRequest,​DeleteParserResponse> handler)
        Deletes parser with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteScheduledTask

        Future<DeleteScheduledTaskResponse> deleteScheduledTask​(DeleteScheduledTaskRequest request,
                                                                AsyncHandler<DeleteScheduledTaskRequest,​DeleteScheduledTaskResponse> handler)
        Delete the scheduled task.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSource

        Future<DeleteSourceResponse> deleteSource​(DeleteSourceRequest request,
                                                  AsyncHandler<DeleteSourceRequest,​DeleteSourceResponse> handler)
        Deletes source with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteUpload

        Future<DeleteUploadResponse> deleteUpload​(DeleteUploadRequest request,
                                                  AsyncHandler<DeleteUploadRequest,​DeleteUploadResponse> handler)
        Deletes an Upload by its reference.

        It deletes all the logs in storage asscoiated with the upload and the corresponding upload metadata.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteUploadFile

        Future<DeleteUploadFileResponse> deleteUploadFile​(DeleteUploadFileRequest request,
                                                          AsyncHandler<DeleteUploadFileRequest,​DeleteUploadFileResponse> handler)
        Deletes a specific log file inside an upload by upload file reference.

        It deletes all the logs from storage associated with the file and the corresponding metadata.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteUploadWarning

        Future<DeleteUploadWarningResponse> deleteUploadWarning​(DeleteUploadWarningRequest request,
                                                                AsyncHandler<DeleteUploadWarningRequest,​DeleteUploadWarningResponse> handler)
        Suppresses a specific warning inside an upload.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • disableArchiving

        Future<DisableArchivingResponse> disableArchiving​(DisableArchivingRequest request,
                                                          AsyncHandler<DisableArchivingRequest,​DisableArchivingResponse> handler)
        This API disables archiving.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • disableAutoAssociation

        Future<DisableAutoAssociationResponse> disableAutoAssociation​(DisableAutoAssociationRequest request,
                                                                      AsyncHandler<DisableAutoAssociationRequest,​DisableAutoAssociationResponse> handler)
        Disables auto association for a log source.

        In the future, this log source would not be automatically associated with any entity that becomes eligible for association. In addition, you may also optionally remove all existing associations for this log source.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • disableIngestTimeRule

        Future<DisableIngestTimeRuleResponse> disableIngestTimeRule​(DisableIngestTimeRuleRequest request,
                                                                    AsyncHandler<DisableIngestTimeRuleRequest,​DisableIngestTimeRuleResponse> handler)
        Disables the specified ingest time rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • disableSourceEventTypes

        Future<DisableSourceEventTypesResponse> disableSourceEventTypes​(DisableSourceEventTypesRequest request,
                                                                        AsyncHandler<DisableSourceEventTypesRequest,​DisableSourceEventTypesResponse> handler)
        Disable one or more event types in a source.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • enableArchiving

        Future<EnableArchivingResponse> enableArchiving​(EnableArchivingRequest request,
                                                        AsyncHandler<EnableArchivingRequest,​EnableArchivingResponse> handler)
        THis API enables archiving.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • enableAutoAssociation

        Future<EnableAutoAssociationResponse> enableAutoAssociation​(EnableAutoAssociationRequest request,
                                                                    AsyncHandler<EnableAutoAssociationRequest,​EnableAutoAssociationResponse> handler)
        Enables auto association for a log source.

        This would initiate immediate association of the source to any eligible entities it is not already associated with, and would also ensure the log source gets associated with entities that are added or become eligible in the future.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • enableIngestTimeRule

        Future<EnableIngestTimeRuleResponse> enableIngestTimeRule​(EnableIngestTimeRuleRequest request,
                                                                  AsyncHandler<EnableIngestTimeRuleRequest,​EnableIngestTimeRuleResponse> handler)
        Enables the specified ingest time rule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • enableSourceEventTypes

        Future<EnableSourceEventTypesResponse> enableSourceEventTypes​(EnableSourceEventTypesRequest request,
                                                                      AsyncHandler<EnableSourceEventTypesRequest,​EnableSourceEventTypesResponse> handler)
        Enable one or more event types in a source.

        An event type and version can be enabled only in one source.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • estimatePurgeDataSize

        Future<EstimatePurgeDataSizeResponse> estimatePurgeDataSize​(EstimatePurgeDataSizeRequest request,
                                                                    AsyncHandler<EstimatePurgeDataSizeRequest,​EstimatePurgeDataSizeResponse> handler)
        This API estimates the size of data to be purged based based on time interval, purge query etc.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • estimateRecallDataSize

        Future<EstimateRecallDataSizeResponse> estimateRecallDataSize​(EstimateRecallDataSizeRequest request,
                                                                      AsyncHandler<EstimateRecallDataSizeRequest,​EstimateRecallDataSizeResponse> handler)
        This API gives an active storage usage estimate for archived data to be recalled and the time range of such data.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • estimateReleaseDataSize

        Future<EstimateReleaseDataSizeResponse> estimateReleaseDataSize​(EstimateReleaseDataSizeRequest request,
                                                                        AsyncHandler<EstimateReleaseDataSizeRequest,​EstimateReleaseDataSizeResponse> handler)
        This API gives an active storage usage estimate for recalled data to be released and the time range of such data.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • exportCustomContent

        Future<ExportCustomContentResponse> exportCustomContent​(ExportCustomContentRequest request,
                                                                AsyncHandler<ExportCustomContentRequest,​ExportCustomContentResponse> handler)
        Exports all custom details of the specified sources, parsers, fields and labels, in zip format.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • exportQueryResult

        Future<ExportQueryResultResponse> exportQueryResult​(ExportQueryResultRequest request,
                                                            AsyncHandler<ExportQueryResultRequest,​ExportQueryResultResponse> handler)
        Export data based on query.

        Endpoint returns a stream of data. Endpoint is synchronous. Queries must deliver first result within 60 seconds or calls are subject to timeout.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • filter

        Future<FilterResponse> filter​(FilterRequest request,
                                      AsyncHandler<FilterRequest,​FilterResponse> handler)
        Each filter specifies an operator, a field and one or more values to be inserted into the provided query as criteria.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getAssociationSummary

        Future<GetAssociationSummaryResponse> getAssociationSummary​(GetAssociationSummaryRequest request,
                                                                    AsyncHandler<GetAssociationSummaryRequest,​GetAssociationSummaryResponse> handler)
        Returns the count of source associations for entities in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getCategory

        Future<GetCategoryResponse> getCategory​(GetCategoryRequest request,
                                                AsyncHandler<GetCategoryRequest,​GetCategoryResponse> handler)
        Gets detailed information about the category with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getColumnNames

        Future<GetColumnNamesResponse> getColumnNames​(GetColumnNamesRequest request,
                                                      AsyncHandler<GetColumnNamesRequest,​GetColumnNamesResponse> handler)
        Extracts column names from the input SQL query.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getConfigWorkRequest

        Future<GetConfigWorkRequestResponse> getConfigWorkRequest​(GetConfigWorkRequestRequest request,
                                                                  AsyncHandler<GetConfigWorkRequestRequest,​GetConfigWorkRequestResponse> handler)
        Returns detailed information about the configuration work request with the specified id.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getField

        Future<GetFieldResponse> getField​(GetFieldRequest request,
                                          AsyncHandler<GetFieldRequest,​GetFieldResponse> handler)
        Gets detailed information about the field with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getFieldsSummary

        Future<GetFieldsSummaryResponse> getFieldsSummary​(GetFieldsSummaryRequest request,
                                                          AsyncHandler<GetFieldsSummaryRequest,​GetFieldsSummaryResponse> handler)
        Returns the count of fields.

        You may optionally specify isShowDetail=true to view a summary of each field data type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getIngestTimeRule

        Future<GetIngestTimeRuleResponse> getIngestTimeRule​(GetIngestTimeRuleRequest request,
                                                            AsyncHandler<GetIngestTimeRuleRequest,​GetIngestTimeRuleResponse> handler)
        Gets detailed information about the specified ingest time rule such as description, defined tags, and free-form tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLabel

        Future<GetLabelResponse> getLabel​(GetLabelRequest request,
                                          AsyncHandler<GetLabelRequest,​GetLabelResponse> handler)
        Gets detailed information about the label with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLabelSummary

        Future<GetLabelSummaryResponse> getLabelSummary​(GetLabelSummaryRequest request,
                                                        AsyncHandler<GetLabelSummaryRequest,​GetLabelSummaryResponse> handler)
        Returns the count of labels.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLogAnalyticsEmBridge

        Future<GetLogAnalyticsEmBridgeResponse> getLogAnalyticsEmBridge​(GetLogAnalyticsEmBridgeRequest request,
                                                                        AsyncHandler<GetLogAnalyticsEmBridgeRequest,​GetLogAnalyticsEmBridgeResponse> handler)
        Retrieve the log analytics enterprise manager bridge with the given id.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLogAnalyticsEntity

        Future<GetLogAnalyticsEntityResponse> getLogAnalyticsEntity​(GetLogAnalyticsEntityRequest request,
                                                                    AsyncHandler<GetLogAnalyticsEntityRequest,​GetLogAnalyticsEntityResponse> handler)
        Retrieve the log analytics entity with the given id.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLogAnalyticsLogGroup

        Future<GetLogAnalyticsLogGroupResponse> getLogAnalyticsLogGroup​(GetLogAnalyticsLogGroupRequest request,
                                                                        AsyncHandler<GetLogAnalyticsLogGroupRequest,​GetLogAnalyticsLogGroupResponse> handler)
        Gets detailed information about the specified log group such as display name, description, defined tags, and free-form tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLogSetsCount

        Future<GetLogSetsCountResponse> getLogSetsCount​(GetLogSetsCountRequest request,
                                                        AsyncHandler<GetLogSetsCountRequest,​GetLogSetsCountResponse> handler)
        This API returns the count of distinct log sets.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLookup

        Future<GetLookupResponse> getLookup​(GetLookupRequest request,
                                            AsyncHandler<GetLookupRequest,​GetLookupResponse> handler)
        Gets detailed information about the lookup with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getLookupSummary

        Future<GetLookupSummaryResponse> getLookupSummary​(GetLookupSummaryRequest request,
                                                          AsyncHandler<GetLookupSummaryRequest,​GetLookupSummaryResponse> handler)
        Returns the count of user created and oracle defined lookups.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getNamespace

        Future<GetNamespaceResponse> getNamespace​(GetNamespaceRequest request,
                                                  AsyncHandler<GetNamespaceRequest,​GetNamespaceResponse> handler)
        This API gets the namespace details of a tenancy already onboarded in Logging Analytics Application
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getParser

        Future<GetParserResponse> getParser​(GetParserRequest request,
                                            AsyncHandler<GetParserRequest,​GetParserResponse> handler)
        Gets detailed information about the parser with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getParserSummary

        Future<GetParserSummaryResponse> getParserSummary​(GetParserSummaryRequest request,
                                                          AsyncHandler<GetParserSummaryRequest,​GetParserSummaryResponse> handler)
        Returns the count of parsers.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPreferences

        Future<GetPreferencesResponse> getPreferences​(GetPreferencesRequest request,
                                                      AsyncHandler<GetPreferencesRequest,​GetPreferencesResponse> handler)
        Lists the tenant preferences such as DEFAULT_HOMEPAGE and collection properties.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getQueryResult

        Future<GetQueryResultResponse> getQueryResult​(GetQueryResultRequest request,
                                                      AsyncHandler<GetQueryResultRequest,​GetQueryResultResponse> handler)
        Returns the intermediate results for a query that was specified to run asynchronously if the query has not completed, otherwise the final query results identified by a queryWorkRequestId returned when submitting the query execute asynchronously.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getQueryWorkRequest

        Future<GetQueryWorkRequestResponse> getQueryWorkRequest​(GetQueryWorkRequestRequest request,
                                                                AsyncHandler<GetQueryWorkRequestRequest,​GetQueryWorkRequestResponse> handler)
        Retrieve work request details by workRequestId.

        This endpoint can be polled for status tracking of work request. Clients should poll using the interval returned in the retry-after header.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRecallCount

        Future<GetRecallCountResponse> getRecallCount​(GetRecallCountRequest request,
                                                      AsyncHandler<GetRecallCountRequest,​GetRecallCountResponse> handler)
        This API gets the number of recalls made and the maximum recalls that can be made
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRecalledDataSize

        Future<GetRecalledDataSizeResponse> getRecalledDataSize​(GetRecalledDataSizeRequest request,
                                                                AsyncHandler<GetRecalledDataSizeRequest,​GetRecalledDataSizeResponse> handler)
        This API gets the datasize of recalls for a given timeframe
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRulesSummary

        Future<GetRulesSummaryResponse> getRulesSummary​(GetRulesSummaryRequest request,
                                                        AsyncHandler<GetRulesSummaryRequest,​GetRulesSummaryResponse> handler)
        Returns the count of detection rules in a compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getScheduledTask

        Future<GetScheduledTaskResponse> getScheduledTask​(GetScheduledTaskRequest request,
                                                          AsyncHandler<GetScheduledTaskRequest,​GetScheduledTaskResponse> handler)
        Get the scheduled task for the specified task identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSource

        Future<GetSourceResponse> getSource​(GetSourceRequest request,
                                            AsyncHandler<GetSourceRequest,​GetSourceResponse> handler)
        Gets detailed information about the source with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSourceSummary

        Future<GetSourceSummaryResponse> getSourceSummary​(GetSourceSummaryRequest request,
                                                          AsyncHandler<GetSourceSummaryRequest,​GetSourceSummaryResponse> handler)
        Returns the count of sources.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getStorage

        Future<GetStorageResponse> getStorage​(GetStorageRequest request,
                                              AsyncHandler<GetStorageRequest,​GetStorageResponse> handler)
        This API gets the storage configuration of a tenancy
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getStorageUsage

        Future<GetStorageUsageResponse> getStorageUsage​(GetStorageUsageRequest request,
                                                        AsyncHandler<GetStorageUsageRequest,​GetStorageUsageResponse> handler)
        This API gets storage usage information of a tenancy.

        Storage usage information includes active, archived or recalled data. The unit of return data is in bytes.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getStorageWorkRequest

        Future<GetStorageWorkRequestResponse> getStorageWorkRequest​(GetStorageWorkRequestRequest request,
                                                                    AsyncHandler<GetStorageWorkRequestRequest,​GetStorageWorkRequestResponse> handler)
        This API returns work request details specified by {workRequestId}.

        This API can be polled for status tracking of work request. Clients should poll using the interval returned in retry-after header.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getUnprocessedDataBucket

        Future<GetUnprocessedDataBucketResponse> getUnprocessedDataBucket​(GetUnprocessedDataBucketRequest request,
                                                                          AsyncHandler<GetUnprocessedDataBucketRequest,​GetUnprocessedDataBucketResponse> handler)
        This API retrieves details of the configured bucket that stores unprocessed payloads.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getUpload

        Future<GetUploadResponse> getUpload​(GetUploadRequest request,
                                            AsyncHandler<GetUploadRequest,​GetUploadResponse> handler)
        Gets an On-Demand Upload info by reference.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                      AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the status of the work request with the given ID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importCustomContent

        Future<ImportCustomContentResponse> importCustomContent​(ImportCustomContentRequest request,
                                                                AsyncHandler<ImportCustomContentRequest,​ImportCustomContentResponse> handler)
        Imports the specified custom content from the input in zip format.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAssociableEntities

        Future<ListAssociableEntitiesResponse> listAssociableEntities​(ListAssociableEntitiesRequest request,
                                                                      AsyncHandler<ListAssociableEntitiesRequest,​ListAssociableEntitiesResponse> handler)
        Lists the entities in the specified compartment which are (in)eligible for association with this source.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAssociatedEntities

        Future<ListAssociatedEntitiesResponse> listAssociatedEntities​(ListAssociatedEntitiesRequest request,
                                                                      AsyncHandler<ListAssociatedEntitiesRequest,​ListAssociatedEntitiesResponse> handler)
        Lists the association details of entities in the specified compartment that are associated with at least one source.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listAutoAssociations

        Future<ListAutoAssociationsResponse> listAutoAssociations​(ListAutoAssociationsRequest request,
                                                                  AsyncHandler<ListAutoAssociationsRequest,​ListAutoAssociationsResponse> handler)
        Gets information related to auto association for the source with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listCategories

        Future<ListCategoriesResponse> listCategories​(ListCategoriesRequest request,
                                                      AsyncHandler<ListCategoriesRequest,​ListCategoriesResponse> handler)
        Returns a list of categories, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as category name or description.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listConfigWorkRequests

        Future<ListConfigWorkRequestsResponse> listConfigWorkRequests​(ListConfigWorkRequestsRequest request,
                                                                      AsyncHandler<ListConfigWorkRequestsRequest,​ListConfigWorkRequestsResponse> handler)
        Returns the list of configuration work requests such as association or lookup operations, containing detailed information about them.

        You may paginate or limit the number of results.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEffectiveProperties

        Future<ListEffectivePropertiesResponse> listEffectiveProperties​(ListEffectivePropertiesRequest request,
                                                                        AsyncHandler<ListEffectivePropertiesRequest,​ListEffectivePropertiesResponse> handler)
        Returns a list of effective properties for the specified resource.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEncryptionKeyInfo

        Future<ListEncryptionKeyInfoResponse> listEncryptionKeyInfo​(ListEncryptionKeyInfoRequest request,
                                                                    AsyncHandler<ListEncryptionKeyInfoRequest,​ListEncryptionKeyInfoResponse> handler)
        This API returns the list of customer owned encryption key info.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEntityAssociations

        Future<ListEntityAssociationsResponse> listEntityAssociations​(ListEntityAssociationsRequest request,
                                                                      AsyncHandler<ListEntityAssociationsRequest,​ListEntityAssociationsResponse> handler)
        Return a list of log analytics entities associated with input source log analytics entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listFields

        Future<ListFieldsResponse> listFields​(ListFieldsRequest request,
                                              AsyncHandler<ListFieldsRequest,​ListFieldsResponse> handler)
        Returns a list of log fields, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by specifying various options including parser and source names.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listIngestTimeRules

        Future<ListIngestTimeRulesResponse> listIngestTimeRules​(ListIngestTimeRulesRequest request,
                                                                AsyncHandler<ListIngestTimeRulesRequest,​ListIngestTimeRulesResponse> handler)
        Returns a list of ingest time rules in a compartment.

        You may limit the number of rules, provide sorting options, and filter the results.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLabelPriorities

        Future<ListLabelPrioritiesResponse> listLabelPriorities​(ListLabelPrioritiesRequest request,
                                                                AsyncHandler<ListLabelPrioritiesRequest,​ListLabelPrioritiesResponse> handler)
        Lists the available problem priorities that could be associated with a label.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLabelSourceDetails

        Future<ListLabelSourceDetailsResponse> listLabelSourceDetails​(ListLabelSourceDetailsRequest request,
                                                                      AsyncHandler<ListLabelSourceDetailsRequest,​ListLabelSourceDetailsResponse> handler)
        Lists sources using the label, along with configuration details like base field, operator and condition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLabels

        Future<ListLabelsResponse> listLabels​(ListLabelsRequest request,
                                              AsyncHandler<ListLabelsRequest,​ListLabelsResponse> handler)
        Returns a list of labels, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as label name, display name, description and priority.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLogAnalyticsEntityTopology

        Future<ListLogAnalyticsEntityTopologyResponse> listLogAnalyticsEntityTopology​(ListLogAnalyticsEntityTopologyRequest request,
                                                                                      AsyncHandler<ListLogAnalyticsEntityTopologyRequest,​ListLogAnalyticsEntityTopologyResponse> handler)
        Return a log analytics entity topology collection that contains a set of log analytics entities and a set of relationships between those, for the input source entity.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLogAnalyticsLogGroups

        Future<ListLogAnalyticsLogGroupsResponse> listLogAnalyticsLogGroups​(ListLogAnalyticsLogGroupsRequest request,
                                                                            AsyncHandler<ListLogAnalyticsLogGroupsRequest,​ListLogAnalyticsLogGroupsResponse> handler)
        Returns a list of log groups in a compartment.

        You may limit the number of log groups, provide sorting options, and filter the results by specifying a display name.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLogSets

        Future<ListLogSetsResponse> listLogSets​(ListLogSetsRequest request,
                                                AsyncHandler<ListLogSetsRequest,​ListLogSetsResponse> handler)
        This API returns a list of log sets.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listLookups

        Future<ListLookupsResponse> listLookups​(ListLookupsRequest request,
                                                AsyncHandler<ListLookupsRequest,​ListLookupsResponse> handler)
        Returns a list of lookups, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as lookup name, description and type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMetaSourceTypes

        Future<ListMetaSourceTypesResponse> listMetaSourceTypes​(ListMetaSourceTypesRequest request,
                                                                AsyncHandler<ListMetaSourceTypesRequest,​ListMetaSourceTypesResponse> handler)
        Lists the types of log sources supported.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listNamespaces

        Future<ListNamespacesResponse> listNamespaces​(ListNamespacesRequest request,
                                                      AsyncHandler<ListNamespacesRequest,​ListNamespacesResponse> handler)
        Given a tenancy OCID, this API returns the namespace of the tenancy if it is valid and subscribed to the region.

        The result also indicates if the tenancy is onboarded with Logging Analytics.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listOverlappingRecalls

        Future<ListOverlappingRecallsResponse> listOverlappingRecalls​(ListOverlappingRecallsRequest request,
                                                                      AsyncHandler<ListOverlappingRecallsRequest,​ListOverlappingRecallsResponse> handler)
        This API gets the list of overlapping recalls made in the given timeframe
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listParserFunctions

        Future<ListParserFunctionsResponse> listParserFunctions​(ListParserFunctionsRequest request,
                                                                AsyncHandler<ListParserFunctionsRequest,​ListParserFunctionsResponse> handler)
        Lists the parser functions defined for the specified parser.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listParserMetaPlugins

        Future<ListParserMetaPluginsResponse> listParserMetaPlugins​(ListParserMetaPluginsRequest request,
                                                                    AsyncHandler<ListParserMetaPluginsRequest,​ListParserMetaPluginsResponse> handler)
        Lists the parser meta plugins available for defining parser functions.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listParsers

        Future<ListParsersResponse> listParsers​(ListParsersRequest request,
                                                AsyncHandler<ListParsersRequest,​ListParsersResponse> handler)
        Returns a list of parsers, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as parser name, type, display name and description.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPropertiesMetadata

        Future<ListPropertiesMetadataResponse> listPropertiesMetadata​(ListPropertiesMetadataRequest request,
                                                                      AsyncHandler<ListPropertiesMetadataRequest,​ListPropertiesMetadataResponse> handler)
        Returns a list of properties along with their metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listQueryWorkRequests

        Future<ListQueryWorkRequestsResponse> listQueryWorkRequests​(ListQueryWorkRequestsRequest request,
                                                                    AsyncHandler<ListQueryWorkRequestsRequest,​ListQueryWorkRequestsResponse> handler)
        List active asynchronous queries.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listRecalledData

        Future<ListRecalledDataResponse> listRecalledData​(ListRecalledDataRequest request,
                                                          AsyncHandler<ListRecalledDataRequest,​ListRecalledDataResponse> handler)
        This API returns the list of recalled data of a tenancy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listResourceCategories

        Future<ListResourceCategoriesResponse> listResourceCategories​(ListResourceCategoriesRequest request,
                                                                      AsyncHandler<ListResourceCategoriesRequest,​ListResourceCategoriesResponse> handler)
        Returns a list of resources and their category assignments.

        You may limit the number of results, provide sorting order, and filter by information such as resource type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listRules

        Future<ListRulesResponse> listRules​(ListRulesRequest request,
                                            AsyncHandler<ListRulesRequest,​ListRulesResponse> handler)
        Returns a list of ingest time rules and scheduled tasks in a compartment.

        You may limit the number of items returned, provide sorting options, and filter the results.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listScheduledTasks

        Future<ListScheduledTasksResponse> listScheduledTasks​(ListScheduledTasksRequest request,
                                                              AsyncHandler<ListScheduledTasksRequest,​ListScheduledTasksResponse> handler)
        Lists scheduled tasks.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSourceAssociations

        Future<ListSourceAssociationsResponse> listSourceAssociations​(ListSourceAssociationsRequest request,
                                                                      AsyncHandler<ListSourceAssociationsRequest,​ListSourceAssociationsResponse> handler)
        Returns the list of entity associations in the input compartment for the specified source.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSourceEventTypes

        Future<ListSourceEventTypesResponse> listSourceEventTypes​(ListSourceEventTypesRequest request,
                                                                  AsyncHandler<ListSourceEventTypesRequest,​ListSourceEventTypesResponse> handler)
        Lists the event types mapped to the source with the specified name.

        The event type string could be the fully qualified name or a prefix that matches the event type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSourceLabelOperators

        Future<ListSourceLabelOperatorsResponse> listSourceLabelOperators​(ListSourceLabelOperatorsRequest request,
                                                                          AsyncHandler<ListSourceLabelOperatorsRequest,​ListSourceLabelOperatorsResponse> handler)
        Lists the supported conditional operators that could be used for matching log field values to generate a label.

        You may use patterns to specify a condition. If a log entry matches that condition, it is tagged with the corresponding label.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSourceMetaFunctions

        Future<ListSourceMetaFunctionsResponse> listSourceMetaFunctions​(ListSourceMetaFunctionsRequest request,
                                                                        AsyncHandler<ListSourceMetaFunctionsRequest,​ListSourceMetaFunctionsResponse> handler)
        Lists the functions that could be used to enrich log entries based on meaningful information extracted from the log fields.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSourcePatterns

        Future<ListSourcePatternsResponse> listSourcePatterns​(ListSourcePatternsRequest request,
                                                              AsyncHandler<ListSourcePatternsRequest,​ListSourcePatternsResponse> handler)
        Lists the source patterns for the source with the specified name.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSources

        Future<ListSourcesResponse> listSources​(ListSourcesRequest request,
                                                AsyncHandler<ListSourcesRequest,​ListSourcesResponse> handler)
        Returns a list of sources, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as display name, description and entity type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listStorageWorkRequests

        Future<ListStorageWorkRequestsResponse> listStorageWorkRequests​(ListStorageWorkRequestsRequest request,
                                                                        AsyncHandler<ListStorageWorkRequestsRequest,​ListStorageWorkRequestsResponse> handler)
        This API lists storage work requests.

        Use query parameters to narrow down or sort the result list.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSupportedTimezones

        Future<ListSupportedTimezonesResponse> listSupportedTimezones​(ListSupportedTimezonesRequest request,
                                                                      AsyncHandler<ListSupportedTimezonesRequest,​ListSupportedTimezonesResponse> handler)
        Gets list of timezones which are supported by on-demand upload.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listUploadFiles

        Future<ListUploadFilesResponse> listUploadFiles​(ListUploadFilesRequest request,
                                                        AsyncHandler<ListUploadFilesRequest,​ListUploadFilesResponse> handler)
        Gets list of files in an upload along with its processing state.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listUploadWarnings

        Future<ListUploadWarningsResponse> listUploadWarnings​(ListUploadWarningsRequest request,
                                                              AsyncHandler<ListUploadWarningsRequest,​ListUploadWarningsResponse> handler)
        Gets list of warnings in an upload caused by incorrect configuration.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listUploads

        Future<ListUploadsResponse> listUploads​(ListUploadsRequest request,
                                                AsyncHandler<ListUploadsRequest,​ListUploadsResponse> handler)
        Gets a list of all On-demand uploads.

        To use this and other API operations, you must be authorized in an IAM policy.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWarnings

        Future<ListWarningsResponse> listWarnings​(ListWarningsRequest request,
                                                  AsyncHandler<ListWarningsRequest,​ListWarningsResponse> handler)
        Returns a list of collection warnings, containing detailed information about them.

        You may limit the number of results, provide sorting order, and filter by information such as start time, end time, warning type, warning state, source name, source pattern and entity name.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                                    AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Return a (paginated) list of errors for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                                AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Return a (paginated) list of logs for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                          AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists the work requests in a compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • offboardNamespace

        Future<OffboardNamespaceResponse> offboardNamespace​(OffboardNamespaceRequest request,
                                                            AsyncHandler<OffboardNamespaceRequest,​OffboardNamespaceResponse> handler)
        Off-boards a tenant from Logging Analytics
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • onboardNamespace

        Future<OnboardNamespaceResponse> onboardNamespace​(OnboardNamespaceRequest request,
                                                          AsyncHandler<OnboardNamespaceRequest,​OnboardNamespaceResponse> handler)
        On-boards a tenant to Logging Analytics.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • parseQuery

        Future<ParseQueryResponse> parseQuery​(ParseQueryRequest request,
                                              AsyncHandler<ParseQueryRequest,​ParseQueryResponse> handler)
        Describe query
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • pauseScheduledTask

        Future<PauseScheduledTaskResponse> pauseScheduledTask​(PauseScheduledTaskRequest request,
                                                              AsyncHandler<PauseScheduledTaskRequest,​PauseScheduledTaskResponse> handler)
        Pause the scheduled task specified by {scheduledTaskId}.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • purgeStorageData

        Future<PurgeStorageDataResponse> purgeStorageData​(PurgeStorageDataRequest request,
                                                          AsyncHandler<PurgeStorageDataRequest,​PurgeStorageDataResponse> handler)
        This API submits a work request to purge data.

        Only data from log groups that the user has permission to delete will be purged. To purge all data, the user must have permission to all log groups.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • putQueryWorkRequestBackground

        Future<PutQueryWorkRequestBackgroundResponse> putQueryWorkRequestBackground​(PutQueryWorkRequestBackgroundRequest request,
                                                                                    AsyncHandler<PutQueryWorkRequestBackgroundRequest,​PutQueryWorkRequestBackgroundResponse> handler)
        Put the work request specified by {workRequestId} into the background.

        Backgrounded queries will preserve query results on query completion for up to 7 days for recall. After 7 days the results and query expire.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • query

        Future<QueryResponse> query​(QueryRequest request,
                                    AsyncHandler<QueryRequest,​QueryResponse> handler)
        Performs a log analytics search, if shouldRunAsync is false returns the query results once they become available subject to 60 second timeout.

        If a query is subject to exceed that time then it should be run asynchronously. Asynchronous query submissions return the queryWorkRequestId to use for execution tracking, query submission lifecycle actions and to poll for query results.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • recallArchivedData

        Future<RecallArchivedDataResponse> recallArchivedData​(RecallArchivedDataRequest request,
                                                              AsyncHandler<RecallArchivedDataRequest,​RecallArchivedDataResponse> handler)
        This API submits a work request to recall archived data based on time interval and data type.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • registerLookup

        Future<RegisterLookupResponse> registerLookup​(RegisterLookupRequest request,
                                                      AsyncHandler<RegisterLookupRequest,​RegisterLookupResponse> handler)
        Creates a lookup with the specified name, type and description.

        The csv file containing the lookup content is passed in as binary data in the request.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • releaseRecalledData

        Future<ReleaseRecalledDataResponse> releaseRecalledData​(ReleaseRecalledDataRequest request,
                                                                AsyncHandler<ReleaseRecalledDataRequest,​ReleaseRecalledDataResponse> handler)
        This API submits a work request to release recalled data based on time interval and data type.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removeEntityAssociations

        Future<RemoveEntityAssociationsResponse> removeEntityAssociations​(RemoveEntityAssociationsRequest request,
                                                                          AsyncHandler<RemoveEntityAssociationsRequest,​RemoveEntityAssociationsResponse> handler)
        Delete association between input source log analytics entity and destination entities.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removePreferences

        Future<RemovePreferencesResponse> removePreferences​(RemovePreferencesRequest request,
                                                            AsyncHandler<RemovePreferencesRequest,​RemovePreferencesResponse> handler)
        Removes the tenant preferences such as DEFAULT_HOMEPAGE and collection properties.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removeResourceCategories

        Future<RemoveResourceCategoriesResponse> removeResourceCategories​(RemoveResourceCategoriesRequest request,
                                                                          AsyncHandler<RemoveResourceCategoriesRequest,​RemoveResourceCategoriesResponse> handler)
        Removes the category assignments of DASHBOARD and SAVEDSEARCH resources.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • removeSourceEventTypes

        Future<RemoveSourceEventTypesResponse> removeSourceEventTypes​(RemoveSourceEventTypesRequest request,
                                                                      AsyncHandler<RemoveSourceEventTypesRequest,​RemoveSourceEventTypesResponse> handler)
        Remove one or more event types from a source.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • resumeScheduledTask

        Future<ResumeScheduledTaskResponse> resumeScheduledTask​(ResumeScheduledTaskRequest request,
                                                                AsyncHandler<ResumeScheduledTaskRequest,​ResumeScheduledTaskResponse> handler)
        Resume the scheduled task specified by {scheduledTaskId}.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • run

        Future<RunResponse> run​(RunRequest request,
                                AsyncHandler<RunRequest,​RunResponse> handler)
        Execute the saved search acceleration task in the foreground.

        The ScheduledTask taskType must be ACCELERATION. Optionally specify time range (timeStart and timeEnd). The default is all time.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • setUnprocessedDataBucket

        Future<SetUnprocessedDataBucketResponse> setUnprocessedDataBucket​(SetUnprocessedDataBucketRequest request,
                                                                          AsyncHandler<SetUnprocessedDataBucketRequest,​SetUnprocessedDataBucketResponse> handler)
        This API configures a bucket to store unprocessed payloads.

        While processing there could be reasons a payload cannot be processed (mismatched structure, corrupted archive format, etc), if configured the payload would be uploaded to the bucket for verification.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • suggest

        Future<SuggestResponse> suggest​(SuggestRequest request,
                                        AsyncHandler<SuggestRequest,​SuggestResponse> handler)
        Returns a context specific list of either commands, fields, or values to append to the end of the specified query string if applicable.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • suppressWarning

        Future<SuppressWarningResponse> suppressWarning​(SuppressWarningRequest request,
                                                        AsyncHandler<SuppressWarningRequest,​SuppressWarningResponse> handler)
        Supresses a list of warnings.

        Any unsuppressed warnings in the input list would be suppressed. Warnings in the input list which are already suppressed will not be modified.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • testParser

        Future<TestParserResponse> testParser​(TestParserRequest request,
                                              AsyncHandler<TestParserRequest,​TestParserResponse> handler)
        Tests the parser definition against the specified example content to ensure fields are successfully extracted.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • unsuppressWarning

        Future<UnsuppressWarningResponse> unsuppressWarning​(UnsuppressWarningRequest request,
                                                            AsyncHandler<UnsuppressWarningRequest,​UnsuppressWarningResponse> handler)
        Unsupresses a list of warnings.

        Any suppressed warnings in the input list would be unsuppressed. Warnings in the input list which are already unsuppressed will not be modified.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateIngestTimeRule

        Future<UpdateIngestTimeRuleResponse> updateIngestTimeRule​(UpdateIngestTimeRuleRequest request,
                                                                  AsyncHandler<UpdateIngestTimeRuleRequest,​UpdateIngestTimeRuleResponse> handler)
        Updates the specified ingest time rule’s description, defined tags, and free-form tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateLogAnalyticsLogGroup

        Future<UpdateLogAnalyticsLogGroupResponse> updateLogAnalyticsLogGroup​(UpdateLogAnalyticsLogGroupRequest request,
                                                                              AsyncHandler<UpdateLogAnalyticsLogGroupRequest,​UpdateLogAnalyticsLogGroupResponse> handler)
        Updates the specified log group’s display name, description, defined tags, and free-form tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateLookup

        Future<UpdateLookupResponse> updateLookup​(UpdateLookupRequest request,
                                                  AsyncHandler<UpdateLookupRequest,​UpdateLookupResponse> handler)
        Updates the metadata of the specified lookup, such as the lookup description.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateLookupData

        Future<UpdateLookupDataResponse> updateLookupData​(UpdateLookupDataRequest request,
                                                          AsyncHandler<UpdateLookupDataRequest,​UpdateLookupDataResponse> handler)
        Updates the lookup content.

        The csv file containing the content to be updated is passed in as binary data in the request.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updatePreferences

        Future<UpdatePreferencesResponse> updatePreferences​(UpdatePreferencesRequest request,
                                                            AsyncHandler<UpdatePreferencesRequest,​UpdatePreferencesResponse> handler)
        Updates the tenant preferences such as DEFAULT_HOMEPAGE and collection properties.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateResourceCategories

        Future<UpdateResourceCategoriesResponse> updateResourceCategories​(UpdateResourceCategoriesRequest request,
                                                                          AsyncHandler<UpdateResourceCategoriesRequest,​UpdateResourceCategoriesResponse> handler)
        Updates the category assignments of DASHBOARD and SAVEDSEARCH resources.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateScheduledTask

        Future<UpdateScheduledTaskResponse> updateScheduledTask​(UpdateScheduledTaskRequest request,
                                                                AsyncHandler<UpdateScheduledTaskRequest,​UpdateScheduledTaskResponse> handler)
        Update the scheduled task.

        Schedules may be updated only for taskType SAVED_SEARCH and PURGE.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateStorage

        Future<UpdateStorageResponse> updateStorage​(UpdateStorageRequest request,
                                                    AsyncHandler<UpdateStorageRequest,​UpdateStorageResponse> handler)
        This API updates the archiving configuration
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • uploadDiscoveryData

        Future<UploadDiscoveryDataResponse> uploadDiscoveryData​(UploadDiscoveryDataRequest request,
                                                                AsyncHandler<UploadDiscoveryDataRequest,​UploadDiscoveryDataResponse> handler)
        Accepts discovery data for processing by Logging Analytics.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • uploadLogEventsFile

        Future<UploadLogEventsFileResponse> uploadLogEventsFile​(UploadLogEventsFileRequest request,
                                                                AsyncHandler<UploadLogEventsFileRequest,​UploadLogEventsFileResponse> handler)
        Accepts log events for processing by Logging Analytics.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • uploadLogFile

        Future<UploadLogFileResponse> uploadLogFile​(UploadLogFileRequest request,
                                                    AsyncHandler<UploadLogFileRequest,​UploadLogFileResponse> handler)
        Accepts log data for processing by Logging Analytics.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • upsertAssociations

        Future<UpsertAssociationsResponse> upsertAssociations​(UpsertAssociationsRequest request,
                                                              AsyncHandler<UpsertAssociationsRequest,​UpsertAssociationsResponse> handler)
        Creates or updates associations between sources and entities.

        All entities should belong to the specified input compartment.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • upsertField

        Future<UpsertFieldResponse> upsertField​(UpsertFieldRequest request,
                                                AsyncHandler<UpsertFieldRequest,​UpsertFieldResponse> handler)
        Creates or updates a field that could be used in parser expressions to extract and assign value.

        To create a field, specify its display name. A name would be generated for the field. For subsequent calls to update the field, include the name attribute.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • upsertLabel

        Future<UpsertLabelResponse> upsertLabel​(UpsertLabelRequest request,
                                                AsyncHandler<UpsertLabelRequest,​UpsertLabelResponse> handler)
        Creates or updates a label that could be used to tag a log entry.

        You may optionally designate the label as a problem, and assign it a priority. You may also provide its related terms (aliases). To create a label, specify its display name. A name would be generated for the label. For subsequent calls to update the label, include the name attribute.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • upsertParser

        Future<UpsertParserResponse> upsertParser​(UpsertParserRequest request,
                                                  AsyncHandler<UpsertParserRequest,​UpsertParserResponse> handler)
        Creates or updates a parser, which defines how fields are extracted from a log entry.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • upsertSource

        Future<UpsertSourceResponse> upsertSource​(UpsertSourceRequest request,
                                                  AsyncHandler<UpsertSourceRequest,​UpsertSourceResponse> handler)
        Creates or updates a log source.

        You may also specify parsers, labels, extended fields etc., for the source.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateAssociationParameters

        Future<ValidateAssociationParametersResponse> validateAssociationParameters​(ValidateAssociationParametersRequest request,
                                                                                    AsyncHandler<ValidateAssociationParametersRequest,​ValidateAssociationParametersResponse> handler)
        Checks if the passed in entities could be associated with the specified sources.

        The validation is performed to ensure that the entities have the relevant property values that are used in the corresponding source patterns.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateEndpoint

        Future<ValidateEndpointResponse> validateEndpoint​(ValidateEndpointRequest request,
                                                          AsyncHandler<ValidateEndpointRequest,​ValidateEndpointResponse> handler)
        Validates the REST endpoint configuration.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateFile

        Future<ValidateFileResponse> validateFile​(ValidateFileRequest request,
                                                  AsyncHandler<ValidateFileRequest,​ValidateFileResponse> handler)
        Validates a log file to check whether it is eligible to be uploaded or not.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateLabelCondition

        Future<ValidateLabelConditionResponse> validateLabelCondition​(ValidateLabelConditionRequest request,
                                                                      AsyncHandler<ValidateLabelConditionRequest,​ValidateLabelConditionResponse> handler)
        Validates specified condition for a source label.

        If both conditionString and conditionBlocks are specified, they would be validated to ensure they represent identical conditions. If one of them is input, the response would include the validated representation of the other structure too. Additionally, if field values are passed, the condition specification would be evaluated against them.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateSource

        Future<ValidateSourceResponse> validateSource​(ValidateSourceRequest request,
                                                      AsyncHandler<ValidateSourceRequest,​ValidateSourceResponse> handler)
        Checks if the specified input is a valid log source definition.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • validateSourceMapping

        Future<ValidateSourceMappingResponse> validateSourceMapping​(ValidateSourceMappingRequest request,
                                                                    AsyncHandler<ValidateSourceMappingRequest,​ValidateSourceMappingResponse> handler)
        Validates the source mapping for a given file and provides match status and the parsed representation of log data.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • verify

        Future<VerifyResponse> verify​(VerifyRequest request,
                                      AsyncHandler<VerifyRequest,​VerifyResponse> handler)
        Verify the accelerated saved search task specified by {scheduledTaskId}.

        For internal use only. Optionally specify whether to return accelerated search results; the default is false. The ScheduledTask taskType must be ACCELERATION.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.