docs: Improve Ambassador pattern description

ambassador/README.md

@@ -11,6 +11,10 @@ tag:
 
 Provide a helper service instance on a client and offload common functionality away from a shared resource.
 
+## Also known as
+
+* Sidecar
+
 ## Explanation
 
 Real world example
@@ -173,14 +177,11 @@ Service result: -1
 
 ## Applicability
 
-Ambassador is applicable when working with a legacy remote service which cannot be modified or would be extremely 
-difficult to modify. Connectivity features can be implemented on the client avoiding the need for changes on the remote 
-service.
+* Cloud Native and Microservices Architectures: Especially useful in distributed systems where it's crucial to monitor, log, and secure inter-service communication.
+* Legacy System Integration: Facilitates communication with newer services by handling necessary but non-core functionalities.
+* Performance Enhancement: Can be used to cache results or compress data to improve communication efficiency.
 
-* Ambassador provides a local interface for a remote service.
-* Ambassador provides logging, circuit breaking, retries and security on the client.
-
-## Typical Use Case
+Typical use cases include:
 
 * Control access to another object
 * Implement logging
@@ -188,15 +189,44 @@ service.
 * Offload remote service tasks
 * Facilitate network connection
 
+## Consequences
+
+Benefits:
+
+* Separation of Concerns: Offloads cross-cutting concerns from the service logic, leading to cleaner, more maintainable code.
+* Reusable Infrastructure Logic: The ambassador pattern allows the same logic (e.g., logging, monitoring) to be reused across multiple services.
+* Improved Security: Centralizes security features like SSL termination or authentication, reducing the risk of misconfiguration.
+* Flexibility: Makes it easier to update or replace infrastructure concerns without modifying the service code.
+
+Trade-offs:
+
+* Increased Complexity: Adds another layer to the architecture, which can complicate the system design and debugging.
+* Potential Performance Overhead: The additional network hop can introduce latency and overhead, particularly if not optimized.
+* Deployment Overhead: Requires additional resources and management for deploying and scaling ambassador services.
+
 ## Known uses
 
+* Service Mesh Implementations: In a service mesh architecture, like Istio or Linkerd, the Ambassador pattern is often employed as a sidecar proxy that handles inter-service communications. This includes tasks such as service discovery, routing, load balancing, telemetry (metrics and tracing), and security (authentication and authorization).
+* API Gateways: API gateways can use the Ambassador pattern to encapsulate common functionalities like rate limiting, caching, request shaping, and authentication. This allows backend services to focus on their core business logic without being burdened by these cross-cutting concerns.
+* Logging and Monitoring: An Ambassador can aggregate logs and metrics from various services and forward them to centralized monitoring tools like Prometheus or ELK Stack (Elasticsearch, Logstash, Kibana). This simplifies the logging and monitoring setup for each service and provides a unified view of the system's health.
+* Security: Security-related functionalities such as SSL/TLS termination, identity verification, and encryption can be managed by an Ambassador. This ensures consistent security practices across services and reduces the likelihood of security breaches due to misconfigurations.
+* Resilience: The Ambassador can implement resilience patterns like circuit breakers, retries, and timeouts. For instance, Netflix's Hystrix library can be used within an Ambassador to prevent cascading failures in a microservices ecosystem.
+* Database Proxy: Ambassadors can act as proxies for database connections, providing functionalities like connection pooling, read/write splitting for replicas, and query caching. This offloads significant complexity from the application services.
+* Legacy System Integration: In scenarios where modern microservices need to communicate with legacy systems, an Ambassador can serve as an intermediary that translates protocols, handles necessary transformations, and implements modern security practices, easing the integration process.
+* Network Optimization: For services deployed across different geographical locations or cloud regions, Ambassadors can optimize communication by compressing data, batching requests, or even implementing smart routing to reduce latency and costs.
 * [Kubernetes-native API gateway for microservices](https://github.com/datawire/ambassador)
 
 ## Related patterns
 
-* [Proxy](https://java-design-patterns.com/patterns/proxy/)
+* [Proxy](https://java-design-patterns.com/patterns/proxy/): Shares similarities with the proxy pattern, but the ambassador pattern specifically focuses on offloading ancillary functionalities.
+* Sidecar: A similar pattern used in the context of containerized applications, where a sidecar container provides additional functionality to the main application container.
+* [Decorator](https://java-design-patterns.com/patterns/decorator/): The decorator pattern is used to add functionality to an object dynamically, while the ambassador pattern is used to offload functionality to a separate object.
 
 ## Credits
 
 * [Ambassador pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/ambassador)
 * [Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services](https://www.amazon.com/s?k=designing+distributed+systems&sprefix=designing+distri%2Caps%2C156&linkCode=ll2&tag=javadesignpat-20&linkId=a12581e625462f9038557b01794e5341&language=en_US&ref_=as_li_ss_tl)
+* [Cloud Native Patterns: Designing Change-tolerant Software](https://amzn.to/3wUAl4O)
+* [Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services](https://amzn.to/3T9g9Uj)
+* [Microservices Patterns: With examples in Java](https://www.amazon.com/gp/product/1617294543/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617294543&linkId=8b4e570267bc5fb8b8189917b461dc60)
+* [Building Microservices: Designing Fine-Grained Systems](https://amzn.to/43aGpSR)

ambassador/src/main/java/com/iluwatar/ambassador/RemoteServiceStatus.java

@@ -24,6 +24,8 @@
  */
 package com.iluwatar.ambassador;
 
+import lombok.Getter;
+
 /**
  * Holds information regarding the status of the Remote Service.
  *
@@ -36,13 +38,10 @@ package com.iluwatar.ambassador;
 public enum RemoteServiceStatus {
   FAILURE(-1);
 
+  @Getter
   private final long remoteServiceStatusValue;
 
   RemoteServiceStatus(long remoteServiceStatusValue) {
     this.remoteServiceStatusValue = remoteServiceStatusValue;
   }
-
-  public long getRemoteServiceStatusValue() {
-    return remoteServiceStatusValue;
-  }
 }