Package io.temporal.common

Class SimplePlugin

  • All Implemented Interfaces:
    ScheduleClientPlugin, WorkflowClientPlugin, io.temporal.serviceclient.WorkflowServiceStubsPlugin, WorkerPlugin
    @Experimental
public abstract class SimplePlugin
extends java.lang.Object
implements io.temporal.serviceclient.WorkflowServiceStubsPlugin, WorkflowClientPlugin, ScheduleClientPlugin, WorkerPlugin
    A plugin that implements WorkflowServiceStubsPlugin, WorkflowClientPlugin, ScheduleClientPlugin, and WorkerPlugin. This class can be used in two ways:
    1. Builder pattern: Use newBuilder(String) to declaratively configure a plugin with callbacks
    2. Subclassing: Extend this class and override specific methods for custom behavior

    Builder Pattern Example

    
 SimplePlugin myPlugin = SimplePlugin.newBuilder("my-plugin")
     .addWorkerInterceptors(new TracingInterceptor())
     .addClientInterceptors(new LoggingInterceptor())
     .customizeDataConverter(existing -> new CodecDataConverter(existing, myCodec))
     .build();

    Subclassing Example

    {@code
 public class TracingPlugin extends SimplePlugin {
     private final Tracer tracer;

     public TracingPlugin(Tracer tracer) {
         super("io.temporal.tracing");
         this.tracer = tracer;
     }
    See Also:
    WorkflowServiceStubsPlugin, WorkflowClientPlugin, ScheduleClientPlugin, WorkerPlugin

    • Constructor Detail

      • SimplePlugin

        protected SimplePlugin​(@Nonnull
                       java.lang.String name)
        Creates a new plugin with the specified name. Use this constructor when subclassing to override specific methods.
        Parameters:
        name - a unique name for this plugin, used for logging and duplicate detection. Recommended format: "organization.plugin-name" (e.g., "io.temporal.tracing")
        Throws:
        java.lang.NullPointerException - if name is null

      • SimplePlugin

        protected SimplePlugin​(@Nonnull
                       SimplePlugin.Builder builder)
        Creates a new plugin from a builder. Use this constructor when subclassing to combine builder configuration with method overrides.
        Parameters:
        builder - the builder with configuration
        Throws:
        java.lang.NullPointerException - if builder is null

    • Method Detail

      • newBuilder

        public static SimplePlugin.Builder newBuilder​(@Nonnull
                                              java.lang.String name)
        Creates a new builder with the specified plugin name.
        Parameters:
        name - a unique name for the plugin, used for logging and duplicate detection. Recommended format: "organization.plugin-name" (e.g., "my-org.tracing")
        Returns:
        a new builder instance

      • getName

        @Nonnull
public java.lang.String getName()
        Description copied from interface: WorkflowClientPlugin
        Returns a unique name for this plugin. Used for logging and duplicate detection. Recommended format: "organization.plugin-name" (e.g., "io.temporal.tracing")
        Specified by:
        getName in interface ScheduleClientPlugin
        Specified by:
        getName in interface WorkerPlugin
        Specified by:
        getName in interface WorkflowClientPlugin
        Specified by:
        getName in interface io.temporal.serviceclient.WorkflowServiceStubsPlugin
        Returns:
        fully qualified plugin name

      • configureServiceStubs

        public void configureServiceStubs​(@Nonnull
                                  io.temporal.serviceclient.WorkflowServiceStubsOptions.Builder builder)
        Specified by:
        configureServiceStubs in interface io.temporal.serviceclient.WorkflowServiceStubsPlugin

      • configureWorkerFactory

        public void configureWorkerFactory​(@Nonnull
                                   WorkerFactoryOptions.Builder builder)
        Description copied from interface: WorkerPlugin
        Allows the plugin to modify worker factory options before the factory is created. Called during configuration phase in forward (registration) order.
        Specified by:
        configureWorkerFactory in interface WorkerPlugin
        Parameters:
        builder - the options builder to modify

      • configureWorker

        public void configureWorker​(@Nonnull
                            java.lang.String taskQueue,
                            @Nonnull
                            WorkerOptions.Builder builder)
        Description copied from interface: WorkerPlugin
        Allows the plugin to modify worker options before a worker is created. Called during configuration phase in forward (registration) order.
        Specified by:
        configureWorker in interface WorkerPlugin
        Parameters:
        taskQueue - the task queue name for the worker being created
        builder - the options builder to modify

      • initializeWorker

        public void initializeWorker​(@Nonnull
                             java.lang.String taskQueue,
                             @Nonnull
                             Worker worker)
        Description copied from interface: WorkerPlugin
        Called after a worker is created, allowing plugins to register workflows, activities, Nexus services, and other components on the worker.

        This method is called in forward (registration) order immediately after the worker is created in WorkerFactory.newWorker(java.lang.String). This is the appropriate place for registrations because it is called before the worker starts polling.

        Example: 

        {@code
        Specified by:
        initializeWorker in interface WorkerPlugin
        Parameters:
        taskQueue - the task queue name for the worker
        worker - the newly created worker

      • startWorker

        public void startWorker​(@Nonnull
                        java.lang.String taskQueue,
                        @Nonnull
                        Worker worker,
                        @Nonnull
                        java.util.function.BiConsumer<java.lang.String,​Worker> next)
        Description copied from interface: WorkerPlugin
        Allows the plugin to wrap individual worker startup. Called during execution phase in reverse order (first plugin wraps all others) when WorkerFactory.start() is invoked.

        This method is called for each worker when the factory starts. Use this for per-worker resource initialization, logging, or metrics. Note that workflow/activity registration should be done in WorkerPlugin.initializeWorker(java.lang.String, io.temporal.worker.Worker) instead, as this method is called after registrations are finalized.

        Example: 

        {@code
        Specified by:
        startWorker in interface WorkerPlugin
        Parameters:
        taskQueue - the task queue name for the worker
        worker - the worker being started
        next - callback that starts the next in chain (eventually starts the actual worker)

      • connectServiceClient

        public io.temporal.serviceclient.WorkflowServiceStubs connectServiceClient​(io.temporal.serviceclient.WorkflowServiceStubsOptions options,
                                                                           java.util.function.Supplier<io.temporal.serviceclient.WorkflowServiceStubs> next)
        Specified by:
        connectServiceClient in interface io.temporal.serviceclient.WorkflowServiceStubsPlugin

      • startWorkerFactory

        public void startWorkerFactory​(WorkerFactory factory,
                               java.util.function.Consumer<WorkerFactory> next)
        Description copied from interface: WorkerPlugin
        Allows the plugin to wrap worker factory startup. Called during execution phase in reverse order (first plugin wraps all others).

        This method is called when WorkerFactory.start() is invoked. The plugin can perform setup before starting and cleanup logic.

        Example: 

        {@code
        Specified by:
        startWorkerFactory in interface WorkerPlugin
        Parameters:
        factory - the worker factory being started
        next - callback that starts the next in chain (eventually starts actual workers)

      • shutdownWorkerFactory

        public void shutdownWorkerFactory​(WorkerFactory factory,
                                  java.util.function.Consumer<WorkerFactory> next)
        Description copied from interface: WorkerPlugin
        Allows the plugin to wrap worker factory shutdown. Called during shutdown phase in reverse order (first plugin wraps all others).

        This method is called when WorkerFactory.shutdown() or WorkerFactory.shutdownNow() is invoked. The plugin can perform actions before and after the actual shutdown occurs.

        Warning: Exceptions thrown from this method will propagate up and may halt the shutdown process. Plugin authors should handle exceptions appropriately and ensure next is called exactly once. If cleanup code may throw, consider wrapping it in a try-catch to ensure graceful degradation.

        Example: 

        {@code
        Specified by:
        shutdownWorkerFactory in interface WorkerPlugin
        Parameters:
        factory - the worker factory being shut down
        next - callback that shuts down the next in chain (eventually shuts down actual workers)

      • replayWorkflowExecution

        public void replayWorkflowExecution​(@Nonnull
                                    Worker worker,
                                    @Nonnull
                                    WorkflowExecutionHistory history,
                                    @Nonnull
                                    WorkerPlugin.ReplayCallback next)
                             throws java.lang.Exception
        Description copied from interface: WorkerPlugin
        Allows the plugin to wrap workflow execution replay. Called in reverse order (first plugin wraps all others) when replaying a workflow history.

        This method allows plugins to perform setup/teardown around replay, add logging, metrics, or other observability for replay operations.

        Example: 

        {@code
        Specified by:
        replayWorkflowExecution in interface WorkerPlugin
        Parameters:
        worker - the worker performing the replay
        history - the workflow execution history being replayed
        next - callback that performs the next in chain (eventually performs the actual replay)
        Throws:
        java.lang.Exception - if replay fails

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object