MultiObserver COMPOSITE PATTERN

📖 Class Overview

MultiObserver is a concrete implementation of the Composite pattern in the observer ecosystem. It extends ShellObserver and acts as a collection (or a composite) that can hold any number of child observers. When any shell event occurs (session start/end, context change, command execution, errors), MultiObserver iterates through its internal list and delegates the notification to every registered observer.

This design allows you to treat a group of observers as a single entity, making it easy to attach or detach entire sets of observers without modifying core event logic.

🧩 Composite Pattern in Action

Component: ShellObserver (abstract observer interface)
Leaf: Individual concrete observers (e.g., LoggingObserver, MetricsObserver)
Composite: MultiObserver — manages child observers and forwards all events to them.

The MultiObserver itself is a ShellObserver, meaning composites can be nested, offering hierarchical observer structures.

⚙️ Constructor & Initialization

# Example: create empty composite
multi = MultiObserver()

# Or with initial observers
multi = MultiObserver([console_observer, file_observer])

🔁 Public Methods

MultiObserver implements two categories of methods: observer management and event notification forwarding (fulfilling the ShellObserver contract).

➕ Observer Management

📡 Event Forwarding (ShellObserver Implementation)

💻 Usage Example (Python)

The following example demonstrates how to use MultiObserver to combine two different observers: a simple console logger and a mock metrics collector. The composite observer is attached to a shell controller (hypothetical) and all events are broadcasted simultaneously.

from typing import List, Any
from dataclasses import dataclass

# Mock ShellObserver base and CommandResult (for demonstration)
class ShellObserver:
    def on_session_start(self, shell_name: str): pass
    def on_session_end(self, shell_name: str, error: Exception = None): pass
    def on_context_change(self, key: str, value: Any): pass
    def on_command_start(self, executable: str, final_args: List[str]): pass
    def on_command_result(self, result: 'CommandResult'): pass
    def on_error(self, message: str, error: Exception = None): pass

@dataclass
class CommandResult:
    command: str
    exit_code: int
    stdout: str
    stderr: str

# Concrete observer 1: prints events to console
class ConsoleObserver(ShellObserver):
    def on_session_start(self, shell_name: str):
        print(f"[Console] Session '{shell_name}' started")
    def on_command_result(self, result: CommandResult):
        print(f"[Console] Command '{result.command}' finished with code {result.exit_code}")
    def on_error(self, message: str, error: Exception = None):
        print(f"[Console] Error: {message} | {error}")

# Concrete observer 2: counts commands
class CounterObserver(ShellObserver):
    def __init__(self):
        self.command_count = 0
    def on_command_start(self, executable: str, final_args: List[str]):
        self.command_count += 1
        print(f"[Counter] commands seen so far: {self.command_count}")
    def on_session_end(self, shell_name: str, error: Exception = None):
        print(f"[Counter] total commands in session: {self.command_count}")

# ----- Using MultiObserver -----
if __name__ == "__main__":
    console = ConsoleObserver()
    counter = CounterObserver()
    
    # Create composite observer and attach both
    multi = MultiObserver([console, counter])
    
    # Simulate shell events
    multi.on_session_start("bash")
    multi.on_command_start("/bin/ls", ["ls", "-la"])
    multi.on_command_result(CommandResult("ls -la", 0, "file1 file2", ""))
    multi.on_command_start("/usr/bin/python", ["python", "--version"])
    multi.on_command_result(CommandResult("python --version", 0, "Python 3.11", ""))
    multi.on_error("Config file missing", None)
    multi.on_session_end("bash")
    
    # Output will show both observers reacting to every event.
    # The counter observer increments on command_start,
    # ConsoleObserver prints each event line.

📋 ShellObserver Contract

The MultiObserver relies on the standard observer interface. Each child observer must implement the following methods. This design aligns with the Observer pattern and guarantees polymorphic event handling.

By implementing the same interface, MultiObserver transparently composes any number of observers and behaves exactly like any other ShellObserver.

🎯 Design Highlights & Best Practices

• Open/Closed Principle: MultiObserver is closed for modification but open for extension — you can add new types of observers without altering the composite.
• Fail-Safe Iteration: The composite iterates over a list copy? The current implementation iterates directly over self.observers. For production, consider handling exceptions per observer so one failing observer doesn't break others.
• Dynamic Composition: Use add_observer to attach observers at runtime, making the system flexible.
• Nesting composites: Since MultiObserver inherits from ShellObserver, you can add a MultiObserver inside another MultiObserver for hierarchical grouping.