Package com.oracle.bmc.logging

Interface LoggingManagementAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    LoggingManagementAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20200531")
public interface LoggingManagementAsync
extends AutoCloseable
    Use the Logging Management API to create, read, list, update, move and delete log groups, log objects, log saved searches, and agent configurations.

    For more information, see [Logging Overview](https://docs.oracle.com/iaas/Content/Logging/Concepts/loggingoverview.htm).

    • 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

      • changeLogLogGroup

        Future<ChangeLogLogGroupResponse> changeLogLogGroup​(ChangeLogLogGroupRequest request,
                                                    AsyncHandler<ChangeLogLogGroupRequest,​ChangeLogLogGroupResponse> handler)
        Moves a log into a different log group within the same tenancy.

        When provided, the If-Match is checked against the ETag values of the 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.

      • createLog

        Future<CreateLogResponse> createLog​(CreateLogRequest request,
                                    AsyncHandler<CreateLogRequest,​CreateLogResponse> handler)
        Creates a log within the specified log group.

        This call fails if a log group has already been created with the same displayName or (service, resource, category) triplet.

        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.

      • createLogGroup

        Future<CreateLogGroupResponse> createLogGroup​(CreateLogGroupRequest request,
                                              AsyncHandler<CreateLogGroupRequest,​CreateLogGroupResponse> handler)
        Create a new log group with a unique display name.

        This call fails if the log group is already created with the same displayName in the 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.

      • createLogSavedSearch

        Future<CreateLogSavedSearchResponse> createLogSavedSearch​(CreateLogSavedSearchRequest request,
                                                          AsyncHandler<CreateLogSavedSearchRequest,​CreateLogSavedSearchResponse> handler)
        Creates a new LogSavedSearch.
        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.

      • deleteLog

        Future<DeleteLogResponse> deleteLog​(DeleteLogRequest request,
                                    AsyncHandler<DeleteLogRequest,​DeleteLogResponse> handler)
        Deletes the log object in a log group.
        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.

      • deleteLogGroup

        Future<DeleteLogGroupResponse> deleteLogGroup​(DeleteLogGroupRequest request,
                                              AsyncHandler<DeleteLogGroupRequest,​DeleteLogGroupResponse> handler)
        Deletes the specified log group.
        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.

      • deleteLogSavedSearch

        Future<DeleteLogSavedSearchResponse> deleteLogSavedSearch​(DeleteLogSavedSearchRequest request,
                                                          AsyncHandler<DeleteLogSavedSearchRequest,​DeleteLogSavedSearchResponse> handler)
        Deletes the specified LogSavedSearch.
        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.

      • deleteWorkRequest

        Future<DeleteWorkRequestResponse> deleteWorkRequest​(DeleteWorkRequestRequest request,
                                                    AsyncHandler<DeleteWorkRequestRequest,​DeleteWorkRequestResponse> handler)
        Cancel a work request that has not started yet.
        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.

      • getLog

        Future<GetLogResponse> getLog​(GetLogRequest request,
                              AsyncHandler<GetLogRequest,​GetLogResponse> handler)
        Gets the log object configuration for the log object OCID.
        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.

      • getLogGroup

        Future<GetLogGroupResponse> getLogGroup​(GetLogGroupRequest request,
                                        AsyncHandler<GetLogGroupRequest,​GetLogGroupResponse> handler)
        Get the specified log group’s information.
        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.

      • getLogSavedSearch

        Future<GetLogSavedSearchResponse> getLogSavedSearch​(GetLogSavedSearchRequest request,
                                                    AsyncHandler<GetLogSavedSearchRequest,​GetLogSavedSearchResponse> handler)
        Retrieves a LogSavedSearch.
        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 details 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.

      • listLogGroups

        Future<ListLogGroupsResponse> listLogGroups​(ListLogGroupsRequest request,
                                            AsyncHandler<ListLogGroupsRequest,​ListLogGroupsResponse> handler)
        Lists all log groups for the specified compartment or 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.

      • listLogSavedSearches

        Future<ListLogSavedSearchesResponse> listLogSavedSearches​(ListLogSavedSearchesRequest request,
                                                          AsyncHandler<ListLogSavedSearchesRequest,​ListLogSavedSearchesResponse> handler)
        Lists LogSavedSearches for this 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.

      • listLogs

        Future<ListLogsResponse> listLogs​(ListLogsRequest request,
                                  AsyncHandler<ListLogsRequest,​ListLogsResponse> handler)
        Lists the specified log group’s log objects.
        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.

      • listServices

        Future<ListServicesResponse> listServices​(ListServicesRequest request,
                                          AsyncHandler<ListServicesRequest,​ListServicesResponse> handler)
        Lists all services that support logging.
        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 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 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.

      • updateLog

        Future<UpdateLogResponse> updateLog​(UpdateLogRequest request,
                                    AsyncHandler<UpdateLogRequest,​UpdateLogResponse> handler)
        Updates the existing log object with the associated configuration.

        This call fails if the log object does not exist.

        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.

      • updateLogGroup

        Future<UpdateLogGroupResponse> updateLogGroup​(UpdateLogGroupRequest request,
                                              AsyncHandler<UpdateLogGroupRequest,​UpdateLogGroupResponse> handler)
        Updates the existing log group with the associated configuration.

        This call fails if the log group does not exist.

        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.

      • updateLogSavedSearch

        Future<UpdateLogSavedSearchResponse> updateLogSavedSearch​(UpdateLogSavedSearchRequest request,
                                                          AsyncHandler<UpdateLogSavedSearchRequest,​UpdateLogSavedSearchResponse> handler)
        Updates an existing LogSavedSearch.
        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.