<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Oracle Coherence - Medium]]></title>
        <description><![CDATA[Oracle Coherence is the world’s first and leading in-memory data grid, enabling performance and scalability of mission-critical applications. Often imitated, but never duplicated, it is now available for everyone to use free of charge. - Medium]]></description>
        <link>https://medium.com/oracle-coherence?source=rss----8c5a819cedd6---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Oracle Coherence - Medium</title>
            <link>https://medium.com/oracle-coherence?source=rss----8c5a819cedd6---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 00:11:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/oracle-coherence" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Announcing Coherence CE 26.07: Unified Persistence, Virtual Threads, and More]]></title>
            <link>https://medium.com/oracle-coherence/announcing-coherence-ce-26-07-unified-persistence-virtual-threads-and-more-cf5cfad33cf4?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/cf5cfad33cf4</guid>
            <category><![CDATA[persistence]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[announcements]]></category>
            <dc:creator><![CDATA[Aleks Seovic]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 01:55:10 GMT</pubDate>
            <atom:updated>2026-09-18T01:55:08.865Z</atom:updated>
            <content:encoded><![CDATA[<h4>A purpose-built persistence engine, new concurrency options, stronger serialization security, and a new quarterly release cadence.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qN---GuRPRQthf5LRSfdDA.png" /></figure><p>The Coherence team is pleased to announce the availability of <a href="https://github.com/oracle/coherence/releases/tag/26.07">Coherence Community Edition (CE) 26.07</a>.</p><p>Release 26.07 requires Java 17 or later, with some features requiring Java 21 or later. It is one of our most significant CE releases in recent years, led by Unified Persistence: a new journal-based persistence engine designed specifically for Coherence. The release also adds an opt-in Virtual Daemon Pool based on Java virtual threads, makes the existing platform-thread pools smarter under blocking workloads, and introduces a comprehensive serialization-hardening framework.</p><p>Release artifacts are available from:</p><p>- <a href="https://github.com/oracle/coherence/releases/tag/26.07">Source code and complete release notes</a> on GitHub<br>- <a href="https://central.sonatype.com/artifact/com.oracle.coherence.ce/coherence-bom/26.07">Artifacts</a> on Maven Central<br>- <a href="https://github.com/oracle/coherence/pkgs/container/coherence-ce">Container images</a> on GitHub<br>- Documentation guides for <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/01_unified_persistence.adoc">Unified Persistence</a>, <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/02_daemon_pool_dynamic_resizing.adoc">Daemon Pool Dynamic Resizing</a>, <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/03_virtual_daemon_pool.adoc">Virtual Daemon Pool</a>, and <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/04_serialization_hardening.adoc">Serialization Hardening</a></p><h3>A new quarterly release cadence</h3><p>With 26.07, Coherence CE is moving to a quarterly release cadence aligned with the commercial Coherence patch schedule.</p><p>Going forward, CE release trains will be identified by the target quarter: <strong>YY.01</strong>, <strong>YY.04</strong>, <strong>YY.07</strong>, and <strong>YY.10</strong>, corresponding to commercial January, April, July, and October CPUs. The identifier is a release-train name rather than a promise that the release will be published during that exact calendar month — CE release may arrive a month or so later, giving us time to incorporate the latest security fixes from the corresponding commercial patch before publishing the Community Edition release.</p><p>This change gives CE users a more predictable flow of enhancements and fixes while keeping Community Edition closely aligned with the security posture of our commercial releases.</p><h3>Unified Persistence</h3><p>The headline feature in 26.07 is <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/01_unified_persistence.adoc">Unified Persistence</a>, a new persistence engine built around Coherence’s partitioned architecture and access patterns.</p><p>The existing Berkeley DB-based persistence implementation has served Coherence well, but it is a general-purpose embedded database sitting underneath a system that already knows how its data is partitioned, replicated, transferred, and recovered. Unified Persistence removes that mismatch and replaces it with a storage engine purpose-built for Coherence.</p><p>Every mutation is appended to a journal owned by a specific partition. An in-memory radix index maps each cache key to the precise journal file and byte offset containing its current value, allowing direct point reads without traversing an on-disk database index. During recovery, Coherence loads a checkpoint of that radix index and then replays only the journal entries written after the checkpoint. The result is a deliberately simple I/O model: append-oriented writes, indexed reads, and mostly sequential recovery.</p><p>Snapshots benefit from the same design. Completed journal files are immutable, so on file systems that support hard links, Coherence can link those files into a snapshot instead of copying them. Snapshot creation is therefore nearly instantaneous and initially consumes almost no additional disk space. Background compaction reclaims space from superseded and deleted entries without changing the append-only write path.</p><p>Unified Persistence supports three deployment models:</p><p>1. <strong>Side-channel persistence</strong> is the simplest migration path from Berkeley DB. Keep the existing backing-map configuration and change the persistence environment to use the journal engine.<br>2. <strong>Unified backing map</strong> uses <strong>&lt;journal-scheme&gt;</strong> as the primary backing map. The journal becomes the authoritative cache store, eliminating the duplicate write through a separate persistence side channel.<br>3. <strong>Journal backup map</strong> stores backup partitions in the journal as well. Combined with <strong>&lt;journal-scheme&gt;</strong>, this provides a fully unified model with one durable write for the primary and one for the backup.</p><p>All three models participate in the standard Coherence persistence lifecycle, including active, active-backup, active-async, and on-demand persistence; snapshots and archival; partition transfer; and recovery. Existing applications can migrate either through a controlled import from a Berkeley DB snapshot or through a rolling restart in which Berkeley DB and journal members coexist temporarily while partitions move to the new members.</p><p>Operators also get a dedicated journal persistence MBean for open extents, compaction progress, and recovery summaries, plus Java Flight Recorder events that break recovery into checkpoint-load, journal-scan, journal-replay, and total phases.</p><h3>Virtual Daemon Pool</h3><p>Coherence 26.07 adds an opt-in <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/03_virtual_daemon_pool.adoc">Virtual Daemon Pool</a> for Java 21 and later. It runs service tasks on Java virtual threads while preserving Coherence’s ordering and request-processing semantics.</p><p>Virtual threads are particularly useful when a service performs blocking work such as persistence I/O, network calls, or <strong>CacheLoader</strong> and <strong>CacheStore</strong> operations. When a virtual thread blocks, its carrier thread is released to run other work, so the service does not need a large pool of operating-system threads simply to absorb stalls.</p><p>Coherence also preserves same-key mutation ordering without parking a set of workers behind the same entry lock. Mutating tasks for a key are routed through a lightweight per-key mailbox and drained in order by a single virtual thread. Independent keys continue to make progress concurrently.</p><p>The Virtual Daemon Pool is enabled per service:</p><pre>&lt;distributed-scheme&gt;<br>  &lt;scheme-name&gt;orders-distributed&lt;/scheme-name&gt;<br>  &lt;service-name&gt;OrdersService&lt;/service-name&gt;<br>  &lt;daemon-pool&gt;virtual&lt;/daemon-pool&gt;<br>  &lt;task-limit&gt;10000&lt;/task-limit&gt;<br>  &lt;backing-map-scheme&gt;<br>    &lt;local-scheme/&gt;<br>   &lt;/backing-map-scheme&gt;<br>&lt;/distributed-scheme&gt;</pre><p>The optional <strong>&lt;task-limit&gt;</strong> provides an aggregate ceiling when an application needs to protect memory or a downstream resource. More targeted admission windows for ordinary, read-only, and same-key mailbox work adapt automatically to the live workload.</p><p>The platform-thread pool remains the default and continues to be the best choice for many short, CPU-bound operations. Virtual threads are an architectural choice, not a universal performance switch: enable them on services whose blocking, hot-key contention, or substantial task bodies can amortize their scheduling cost, and validate with a representative workload.</p><h3>Smarter platform-thread pools</h3><p>The traditional platform-thread <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/02_daemon_pool_dynamic_resizing.adoc">Daemon Pool</a> also gets a major upgrade in 26.07.</p><p>Daemon Pools continue to resize between their configured minimum and maximum, but they now use throughput, utilization, queue pressure, worker CPU activity, and association width to distinguish CPU-bound work from blocking or I/O-bound work. A CPU-bound service stays near the useful processor count. A service whose workers spend significant time blocked can probe beyond that point, but Coherence retains the added concurrency only when measured throughput improves. Ineffective growth is automatically rolled back.</p><p>Pools react quickly to bursts, shrink gradually with a cooldown to avoid oscillation, and continually seek a useful operating point rather than treating the processor count as a universal ceiling. If no maximum is configured, Coherence derives a safe process-wide worker budget from available processors, memory, estimated thread-stack cost, and operating-system limits. Explicitly configured finite limits remain authoritative.</p><p>This gives existing applications better behavior under mixed and blocking workloads without requiring them to adopt virtual threads or redesign their service configuration.</p><h3>Serialization hardening</h3><p>Release 26.07 introduces a common <a href="https://github.com/oracle/coherence/blob/v26.07/prj/docs/core/04_serialization_hardening.adoc">Serialization Hardening</a> model across Java serialization, POF, <strong>ExternalizableLite</strong>, dynamic classes and lambdas, and remotely executable objects.</p><p>JEP 290 filters are valuable, but they apply to <strong>ObjectInputStream</strong>; most Coherence traffic uses other serialization paths. The new framework applies a shared allowlist and policy model across those paths, integrates with JEP 290 where Java serialization is used, validates dynamic class and lambda bytecode, tightens POF type handling, and distinguishes between classes that may be deserialized and classes that may be executed on behalf of a remote request.</p><p>Applications can generate <strong>META-INF/coherence/security-config.xml</strong> during a Maven or Gradle build. Classes annotated with <strong>@Remote.Allowed</strong> or <strong>@PortableType</strong> are added to the serialization allowlist, while <strong>@Remote.Executable</strong> separately classifies types that the server may execute on behalf of a remote request. Each application module contributes its own generated configuration, and Coherence merges those resources at runtime.</p><p>Compatibility remains the default so existing deployments can upgrade without an immediate configuration change. The recommended migration path is to generate the security configuration, annotate legitimate wire payloads, exercise the application in compatibility mode, inspect <strong>would_reject</strong> telemetry, and then test with:</p><pre>-Dcoherence.security.mode=hardened</pre><p>Once enabled, hardened mode fails closed at supported serialization and remote-execution boundaries. JMX and metrics expose route-aware policy decisions, making it possible to see which class, boundary, and reason caused a rejection before changing a policy.</p><h3>More performance, observability, and reliability improvements</h3><p>The four headline features are accompanied by several additional enhancements:</p><p>- <strong>Higher Extend proxy concurrency:</strong> independent TCP client connections now use connection-affine decode pipelines instead of sharing a single serialized acceptor path. Ordering is preserved within each connection while multiple connections are decoded concurrently.<br>- <strong>More efficient Java Extend clients:</strong> default initiator input and output buffers increase from five bytes to 8 KiB, improving throughput and CPU efficiency without changing the wire protocol.<br>- <strong>Lower MessageBus contention:</strong> lock contention on the connection during <strong>send()</strong> operations has been eliminated.</p><p>The release also contains eleven bug fixes across persistence, Paged Topics, MicroProfile Metrics, management connectivity, partition migration, write-behind caches, query execution, and the transport layer. See the <a href="https://github.com/oracle/coherence/releases/tag/26.07">complete release notes</a> for the full list, along with third-party dependency updates to ASM 9.10.1, Jackson 2.21.5, JLine 3.30.16, Netty 4.1.136.Final, and OpenTelemetry 1.64.0.</p><h3>Get Coherence CE 26.07</h3><p>The easiest way to manage Coherence dependencies is with the BOM:</p><pre>&lt;dependencyManagement&gt;<br> &lt;dependencies&gt;<br>   &lt;dependency&gt;<br>     &lt;groupId&gt;com.oracle.coherence.ce&lt;/groupId&gt;<br>     &lt;artifactId&gt;coherence-bom&lt;/artifactId&gt;<br>     &lt;version&gt;26.07&lt;/version&gt;<br>     &lt;type&gt;pom&lt;/type&gt;<br>     &lt;scope&gt;import&lt;/scope&gt;<br>   &lt;/dependency&gt;<br> &lt;/dependencies&gt;<br>&lt;/dependencyManagement&gt;<br>```</pre><p>Container users can pull the release from GitHub Container Registry:</p><pre>docker pull ghcr.io/oracle/coherence-ce:26.07</pre><p>With Unified Persistence, virtual-thread execution, adaptive platform-thread concurrency, and stronger security controls, Coherence CE 26.07 delivers meaningful improvements across the full data path: how data is stored, how work is scheduled, how remote payloads are trusted, and how the system is operated.</p><p>We look forward to hearing how you put it to work.</p><p><em>Coherence is the world’s first and leading in-memory data grid, enabling the performance and scalability of mission-critical applications. Coherence Community Edition is free and open source under the Universal Permissive License.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf5cfad33cf4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/announcing-coherence-ce-26-07-unified-persistence-virtual-threads-and-more-cf5cfad33cf4">Announcing Coherence CE 26.07: Unified Persistence, Virtual Threads, and More</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Started with the Coherence Grafana Dashboards]]></title>
            <link>https://medium.com/oracle-coherence/getting-started-with-the-coherence-grafana-dashboards-71f768ab0354?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/71f768ab0354</guid>
            <category><![CDATA[dashboard]]></category>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[grafana]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Tim Middleton]]></dc:creator>
            <pubDate>Thu, 12 Jun 2025 04:32:05 GMT</pubDate>
            <atom:updated>2025-06-19T08:26:45.130Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CQwrSQ96AhJLY1AHz5o6Zw.png" /></figure><h3>Introduction</h3><p>Oracle Coherence has long supported comprehensive Grafana dashboards for monitoring and observability. These dashboards provide valuable insights into Coherence clusters, whether deployed in Kubernetes, WebLogic Server or running standalone.</p><p>The latest dashboards are compatible with the free <a href="https://github.com/oracle/coherence/releases">Oracle Coherence Community Edition (CE)</a> versions, as well as all Coherence Grid editions. (See the <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/14.1.2/manage/using-coherence-metrics.html">commercial documentation</a> for more details on Coherence Metrics).</p><p>If you’re new to these dashboards, this guide is the perfect way to get started quickly using Docker to set up Grafana, Prometheus, and Coherence.</p><blockquote>With the latest <a href="https://github.com/oracle/coherence-cli/releases/tag/1.10.0">Coherence CLI Release</a>, we have made this setup super easy by only needing to use a few commands.</blockquote><h4>What You’ll Learn</h4><p>In this article, you’ll:</p><ul><li>Deploy a Coherence CE cluster using the Coherence CLI</li><li>Configure the monitoring stack with the newcohctl init monitoring command</li><li>Populate your cluster with data and explore visual metrics</li><li>Explore the setup</li></ul><h4>Prerequisites</h4><p>Before you begin, make sure the following tools are installed and available in your system path:</p><ul><li>Docker or Rancher</li><li>Maven 3.8+</li><li>Java JDK 17+</li></ul><h3>Step 1: Install Coherence CLI and Coherence Cluster</h3><blockquote>Note: Ensure you have Docker, Maven and Java installed and in your path as described above.</blockquote><h4>Install the Coherence CLI</h4><p>If you already have a cluster running, you don’t need to install CLI, just refer to the <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/14.1.2/manage/using-coherence-metrics.html">Coherence Documentation</a> to setup metrics. Otherwise, use the following command to install the CLI and create a development cluster.</p><blockquote>Note: If you already have the CLI installed, you will need to update to the latest release, 1.10.0 or above.</blockquote><p><strong>Linux/MacOS</strong></p><pre>curl -sL https://raw.githubusercontent.com/oracle/coherence-cli/main/scripts/install.sh | bash</pre><p><strong>Windows</strong></p><pre>curl -sLo cohctl.exe &quot;https://github.com/oracle/coherence-cli/releases/download/1.9.1/cohctl-1.9.1-windows-amd64.exe&quot;</pre><blockquote>Note: Replace amd64 with arm for ARM-based systems</blockquote><p>Use the command cohctl version to confirm the Coherence CLI is installed.</p><h4>Create and start a Coherence CE Cluster</h4><p>Use the CLI to spin up a 3-member Coherence CE cluster:</p><pre>cohctl create cluster my-cluster -t 9612 -v 25.03.1</pre><blockquote>We are using the -t option to set the starting metrics port and -v option to set the latest Coherence CE patch. See the <a href="https://docs.coherence.community/coherence-cli/docs/latest/docs/about/overview">Coherence CLI documentation</a> for more information on the CLI.</blockquote><p>Respond y to confirm the cluster configuration.</p><p>After 10 seconds or so, run the following command and you will see a 3 member cluster up and running</p><pre>cohctl get members</pre><p>Output:</p><pre>Using cluster connection &#39;my-cluster&#39; from current context.<br><br>Total cluster members: 3<br>Storage enabled count: 3<br>Departure count:       0<br><br>Cluster Heap - Total: 768 MB Used: 158 MB Available: 610 MB - 79.43% Avail<br>Storage Heap - Total: 768 MB Used: 158 MB Available: 610 MB - 79.43% Avail<br><br>NODE ID  ADDRESS     PORT   PROCESS  MEMBER     ROLE             STORAGE  MAX HEAP  USED HEAP  AVAIL HEAP<br>      1  /127.0.0.1  64305    50756  storage-1  CoherenceServer  true       256 MB      45 MB      211 MB<br>      2  /127.0.0.1  64304    50757  storage-2  CoherenceServer  true       256 MB      49 MB      207 MB<br>      3  /127.0.0.1  64306    50755  storage-0  CoherenceServer  true       256 MB      64 MB      192 MB</pre><h3>Step 2: Setup the Grafana/Prometheus Stack</h3><h4>Intialize the Monitoring Stack</h4><p>Run the following command to initialize the monitoring stack. This only needs to be done once.</p><pre>cohctl init monitoring</pre><p>Output:</p><pre>This command will:<br>1. Create a directory /Users/timbo/.cohctl/monitoring<br>2. Download Grafana dashboards<br>2. Download docker compose files<br>3. Pull Grafana and Prometheus images<br><br>Are you sure you want to initialize monitoring? (y/n) y</pre><p>As it says above, this creates a directory off the hidden ~/.cohctl directory called monitoring where it automatically sets up a docker compose project which will startup Grafana and Prometheus and automatically load the latest dashboards.</p><p>The abbreviated output of the command is below:</p><pre>Ensuring directories...<br>Downloading Grafana dashboards...<br> -  cache-details-dashboard.json<br> -  cache-store-details-dashboard.json<br> -  caches-summary-dashboard.json<br> -  coherence-dashboard-main.json<br> -  elastic-data-summary-dashboard.json<br> -  executor-details.json<br> -  executors-summary.json<br> -  federation-details-dashboard.json<br> -  federation-summary-dashboard.json<br> -  grpc-proxy-details-dashboard.json<br> -  grpc-proxy-summary-dashboard.json<br> -  http-servers-summary-dashboard.json<br> -  machines-summary-dashboard.json<br> -  member-details-dashboard.json<br> -  members-summary-dashboard.json<br> -  persistence-summary-dashboard.json<br> -  proxy-server-detail-dashboard.json<br> -  proxy-servers-summary-dashboard.json<br> -  service-details-dashboard.json<br> -  services-summary-dashboard.json<br> -  topic-details-dashboard.json<br> -  topic-subscriber-details.json<br> -  topic-subscriber-group-details.json<br> -  topics-summary-dashboard.json<br>Downloading docker compose files...<br> -  grafana.ini<br> -  dashboards.yaml<br> -  datasources.yaml<br> -  docker-compose.yaml<br> -  prometheus.yaml<br>Pulling docker images...<br>Issuing docker pull prom/prometheus:v2.53.4<br>v2.53.4: Pulling from prom/prometheus<br>6ce8b87a9754: Pulling fs layer<br>...<br>Digest: sha256:502ad90314c7485892ce696cb14a99fceab9fc27af29f4b427f41bd39701a199<br>Status: Downloaded newer image for prom/prometheus:v2.53.4<br>docker.io/prom/prometheus:v2.53.4<br>Issuing docker pull grafana/grafana:11.6.2<br>11.6.2: Pulling from grafana/grafana<br>6e771e15690e: Already exists<br>bae64c34b0d1: Pulling fs layer<br>...<br>operation completed<br><br>Note: You can change the grafana and prometheus image versions by editing:<br>  /Users/timbo/.cohctl/monitoring/docker-compose.yaml</pre><h4>Start the Monitoring Stack</h4><p>Use the following command to start the monitoring stack:</p><pre>cohctl start monitoring</pre><p>Output:</p><pre>Issuing docker compose -f /Users/timbo/.cohctl/monitoring/docker-compose.yaml up -d<br> Network monitoring_coherence  Creating<br> Network monitoring_coherence  Created<br> Container monitoring-grafana-1  Creating<br> Container monitoring-prometheus-1  Creating<br> Container monitoring-prometheus-1  Created<br> Container monitoring-grafana-1  Created<br> Container monitoring-grafana-1  Starting<br> Container monitoring-prometheus-1  Starting<br> Container monitoring-grafana-1  Started<br> Container monitoring-prometheus-1  Started<br><br>Open the Grafana dashboard at http://localhost:3000/d/coh-main/coherence-dashboard-main, using admin/admin<br><br>Note: If you are running a Coherence version before 14.1.2-0-0 or 25.03, you must set the following<br>property on each cluster member to emit the new style metrics used by the latest dashboards:<br>  -Dcoherence.metrics.legacy.names=false<br><br>Issuing docker ps<br>CONTAINER ID   IMAGE                     COMMAND                  CREATED        STATUS                  PORTS                                         NAMES<br>97d9db318abf   grafana/grafana:11.6.2    &quot;/run.sh&quot;                1 second ago   Up Less than a second   0.0.0.0:3000-&gt;3000/tcp, [::]:3000-&gt;3000/tcp   monitoring-grafana-1<br>e395ce816def   prom/prometheus:v2.53.4   &quot;/bin/prometheus --c…&quot;   1 second ago   Up Less than a second   0.0.0.0:9090-&gt;9090/tcp, [::]:9090-&gt;9090/tcp   monitoring-prometheus-1</pre><h3>Step 3: Access the Dashboards</h3><p>As shown in the output, the URL for the Grafana Dashboards is:</p><p><a href="http://localhost:3000/d/coh-main/coherence-dashboard-main">http://localhost:3000/d/coh-main/coherence-dashboard-main</a></p><p>Username: <em>admin</em>, password: <em>admin</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XoQKJzpkBjQHg7p-lKZIug.png" /></figure><blockquote>Note: If you don’t see your cluster in the Cluster Name drop down, refresh the page as metrics can take a few seconds to trickle through.</blockquote><blockquote>Note: If you still do not see metrics after 2–3 mins are running a Coherence version before 14.1.2–0–0 or 25.03, you must set the following property on each cluster member to emit the new style metrics used by the latest dashboards<br><em>-Dcoherence.metrics.legacy.names=false</em></blockquote><p>You can also open Prometheus to verify that at least 3 of the targets, (cache servers with metrics on endpoint 9612/metricsare UP.</p><p>Prometheus Endpoint: <a href="http://localhost:9090/targets">http://localhost:9090/targets</a></p><p>The above dashboard is the Cluster overview containing a summary of the cluster including: machines, members, services, memory, top queries and and various metrics regarding overall cluster health.</p><p>All dashboards include drill down capability to members, services, caches, etc. to allow you to gain insight into your cluster resources, as well as links in top-right of panels to drill down to relevant data.</p><p>On the right under the available dashboards, you can see the large number of dashboards provided including:</p><ul><li>Cache summary, details and cache store information</li><li>Elastic Data (Grid Edition)</li><li>Executors</li><li>Federation (Grid Edition)</li><li>gRPC and HTTP Proxies</li><li>Machines and members</li><li>Proxy servers, Services, Persistence and Topics</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*tEsFaKaRlhejG45_hUwmjQ.png" /></figure><h3>Step 4: Add Data and View in Grafana</h3><h4>Add cache entries</h4><p>If you installed a cluster using the Coherence CLI, then use the following to start Coherence Query Language client, to add data to the cluster. If you already have a cluster with data, continue to the next step to explore the dashboards.</p><pre>cohctl start cohql</pre><p>At the CohQL&gt; prompt type create cache test and insert data:</p><pre>insert into test key(1) value(&#39;Tim&#39;)<br>insert into test key(2) value(&#39;John&#39;)<br>insert into test key(3) value(&#39;Jenny&#39;)</pre><p>Verify the data was added:</p><pre>select key(),value() from test</pre><p>Output should be:</p><pre>Results<br>[2, &quot;John&quot;]<br>[3, &quot;Jenny&quot;]<br>[1, &quot;Tim&quot;]</pre><p>Click on Available Dashboards and select Caches Summary. You should see a dashboard similar to the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kMtutfrj35gba5DjX34SJA.png" /></figure><p>You can drill down on the PartitionedCache link to see the services or, select the test cache to see the details for the cache.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dsIOYFqY-3ee1Ghlh4Slmw.png" /></figure><h3>Step 5: Explore the docker compose YAML</h3><p>For this new feature we specifically created a directory with a working docker compose so that you can explore and make any modifications you wanted to such as updating the Grafana or Promethues versions.</p><p>Here’s the minimal docker-compose.yaml configuration:</p><pre>services:<br>  prometheus:<br>    image: prom/prometheus:v2.53.4<br>    networks:<br>      coherence:<br>    volumes:<br>      - ./prometheus/prometheus.yaml:/etc/prometheus/prometheus.yaml<br>    command:<br>      - &#39;--config.file=/etc/prometheus/prometheus.yaml&#39;<br>    ports:<br>      - 9090:9090<br>  grafana:<br>    networks:<br>      coherence:<br>    image: grafana/grafana:11.6.2<br>    volumes:<br>      - ./grafana/grafana.ini:/etc/grafana/grafana.ini<br>      - ./grafana/datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml<br>      - ./grafana/dashboards.yaml:/etc/grafana/provisioning/dashboards/dashboards.yaml<br>      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards/dashboards<br>    ports:<br>      - 3000:3000<br>networks:<br>  coherence:</pre><ol><li><a href="https://github.com/tmiddlet2666/coherence-playground/blob/main/monitoring/prometheus/prometheus.yaml">prometheus/prometheus.yaml</a> — configures Prometheus to scrape ports 9612 -&gt; 9619 on your local machine to discover any Coherence metrics ports</li><li>grafana/grafana.ini — creates a new user <strong>admin</strong> with the password <em>admin</em></li><li>grafana/datasources.yaml — adds a new datasource called <strong>prometheus</strong> which the dashboards are expecting</li><li>grafana/dashboards.yaml — automatically loads the dashboards from the grafana/dashboards directory on startup</li></ol><h3>Step 6: Shutdown</h3><p>To stop Grafana and Prometheus run the following command from the monitoring directory:</p><pre>cohctl stop monitoring</pre><p>Output:</p><pre>Are you sure you want to stop monitoring? (y/n) y<br><br>Issuing docker compose -f /Users/timbo/.cohctl/monitoring/docker-compose.yaml down<br> Container monitoring-grafana-1  Stopping<br> Container monitoring-prometheus-1  Stopping<br> Container monitoring-prometheus-1  Stopped<br> Container monitoring-prometheus-1  Removing<br> Container monitoring-prometheus-1  Removed<br> Container monitoring-grafana-1  Stopped<br> Container monitoring-grafana-1  Removing<br> Container monitoring-grafana-1  Removed<br> Network monitoring_coherence  Removing<br> Network monitoring_coherence  Removed<br>Issuing docker ps<br>CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES</pre><p>If you started a cluster using the CLI, then shutdown the cluster using:</p><pre>cohctl stop cluster my-cluster -y</pre><p>Continue exploring the many dashboards available.</p><h3>Summary</h3><ul><li>We learned how to set up observability for Oracle Coherence using Grafana and Prometheus</li><li>We created a Coherence CE cluster using the Coherence CLI</li><li>We initialized and started the monitoring stack via the CLI</li><li>We explored real-time metrics for cluster members, caches, services, and more</li></ul><p>This setup gives developers and ops teams an easy, effective way to gain insight into Coherence clusters</p><h4>Next Steps and More Information</h4><ul><li><a href="https://github.com/oracle/coherence-operator">Deploy Coherence on Kubernetes using the Coherence Operator</a></li><li><a href="https://docs.coherence.community/coherence-operator/docs/latest/docs/metrics/040_dashboards">Full list of Grafana Dashboards</a></li><li><a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/14.1.2/manage/using-coherence-metrics.html">Coherence Metrics Documentation</a></li><li><a href="https://coherence.community/">Coherence Community</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71f768ab0354" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/getting-started-with-the-coherence-grafana-dashboards-71f768ab0354">Getting Started with the Coherence Grafana Dashboards</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coherence Operator 3.5 Released, Listed on OpenShift OperatorHub]]></title>
            <link>https://medium.com/oracle-coherence/coherence-operator-3-5-released-listed-on-openshift-operatorhub-faa6791a1e3b?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/faa6791a1e3b</guid>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[datagrid]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[openshift]]></category>
            <dc:creator><![CDATA[Randy Stafford]]></dc:creator>
            <pubDate>Fri, 23 May 2025 16:28:19 GMT</pubDate>
            <atom:updated>2025-05-23T16:28:18.854Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8hoRvMN4aIghDG2Mha2BUA.png" /><figcaption>OpenShift’s OperatorHub now includes Coherence Operator in its curated list of Kubernetes Operators</figcaption></figure><p>It’s been a minute since we last highlighted a <a href="https://github.com/oracle/coherence-operator/">Coherence Operator</a> release. Almost five years ago, we <a href="https://medium.com/oracle-coherence/coherence-operator-3-released-cbfd01bc56c7">announced</a> the release of Coherence Operator 3.1, and recapped the major changes in release 3.0 compared to release 2.0.</p><p>The slower evolution speed of Coherence Operator since is a testament to the feature completeness, robustness, and stability of the project achieved in the 3.x series. Indeed, over the last five years many Coherence users both external and internal to Oracle have successfully deployed and used Coherence Operator to run dynamic, large, mission-critical Coherence applications on a variety of cloud infrastructure platforms, including Amazon Web Services, Microsoft Azure, Google Cloud Platform, and Oracle Cloud Infrastructure.</p><p>To catch you up, let’s recap the new features and improvements that have come out in the interim, concluding with those in the recently released version 3.5.</p><h4>Release 3.2</h4><p>The release 3.2.x series had a total of 12 patch releases between 3.2.0 in July 2021 and 3.2.11 in April 2023. Important changes introduced in the 3.2.x series were as follows:</p><ul><li>Support for Linux/arm64 platforms</li><li>Documentation on operating Coherence clusters with Istio</li><li>Support for setting the SecurityContext for the Coherence container</li><li>Support for specifying StartupProbes to be added to Coherence Pods</li><li>Support for specifying readiness gates to be added to Coherence Pods</li><li>Support for JVM argument files created when building images with JIB. This allows the Operator to run JIB images with the class path and main class configured when the image was created.</li><li>Ability to trigger an action when a Coherence cluster becomes ready</li><li>Tested on OpenShift 4.10.4 and with eight different Kubernetes versions</li><li>Make the Operator deployment HA by default</li><li>Support and document the use of Kubernetes network policies with the Operator and Coherence clusters</li><li>Combined the Operator and its utilities into a single image</li><li>Tested on Minikube</li><li>Many improvements to the Grafana dashboards accompanying Coherence Operator</li><li>Many upgrades of Go versions and Kubernetes versions used by Coherence Operator</li></ul><h4>Release 3.3</h4><p>The release 3.3.x series had a total of six patch releases between 3.3.0 in September 2023 and 3.3.5 in June 2024. Important changes introduced in the 3.3.x series were as follows:</p><ul><li>Added the Coherence CLI to the Operator image</li><li>Allow external updates to Operator managed resources</li><li>Added support for using envFrom to load environment variables</li><li>Set O/S platform and architecture for images</li><li>Allow global labels and annotations to be specified</li><li>Allow resource limits to be set for the Operator’s init container</li><li>Many improvements to the Grafana dashboards accompanying Coherence Operator</li><li>Many upgrades of Go versions and Kubernetes versions used by Coherence Operator</li></ul><h4>Release 3.4</h4><p>The release 3.4.x series had a total of four patch releases between 3.4.0 in September 2024 and 3.4.3 in March 2024. Important changes introduced in the 3.4.x series were as follows:</p><ul><li>More control over how rolling upgrades of Coherence deployments are performed. As well as the default one Pod at a time upgrade controlled by the StatefulSet controller, other strategies such as upgrading by all Pods on a Node can be configured.</li><li>Apply Helm chart global labels and annotations to all resources in the chart</li><li>Support more ways to configure Coherence site and rack</li><li>Better support for dual-stack Kubernetes clusters</li><li>Apply default topology spread constraints</li><li>Support setting the Lifecycle field on the Coherence container</li></ul><h4>Release 3.5</h4><p>And now Coherence Operator Release 3.5 is here.</p><p>Even though Coherence Operator has been tested on OpenShift since release 3.2.6 in May 2022, it is now included in OpenShift’s curated list of Kubernetes Operators on OperatorHub, and is certified on OpenShift.</p><p>Another major change in Coherence Operator 3.5 has to do with when and how Custom Resource Definitions (CRDs) are installed. Prior to v3.4.3 Coherence Operator would install CRDs when it started. In v3.4.3 the default behavior was changed to not install CRDs, but it was still possible to change the default and get the operator to install CRDs. In v3.5.0 this option has now been completely removed. The install scripts and Helm chart will install the CRDs.</p><p>For complete details on the Coherence Operator 3.5 release, please refer to its <a href="https://github.com/oracle/coherence-operator/releases/tag/v3.5.0">release notes</a>.</p><h4>Summary</h4><p>Coherence Operator on Kubernetes, with accompanying Grafana and Kibana dashboards, has become the most powerful and productive way ever developed to manage and monitor deployments of Coherence applications. The Coherence team has invested heavily in Coherence Operator for over six years, encoding hard-won wisdom, operational best practices, ease of use, automatic HA on cloud infrastructure, and world-class observabililty into this industry de-facto standard approach. To not use Coherence Operator is to miss out, or worse yet, to reinvent a sophisticated wheel long in the making.</p><p>To get started with <a href="https://github.com/oracle/coherence-operator/">Coherence Operator</a>, jump in to <a href="https://oracle.github.io/coherence-operator/docs/latest/#/docs/about/01_overview">the Release 3.5 documentation</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=faa6791a1e3b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/coherence-operator-3-5-released-listed-on-openshift-operatorhub-faa6791a1e3b">Coherence Operator 3.5 Released, Listed on OpenShift OperatorHub</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Announcing Coherence CE 25.03 and Coherence CLI 1.9.0]]></title>
            <link>https://medium.com/oracle-coherence/announcing-coherence-ce-25-03-and-coherence-cli-1-9-0-146879b24a62?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/146879b24a62</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Randy Stafford]]></dc:creator>
            <pubDate>Tue, 01 Apr 2025 04:32:08 GMT</pubDate>
            <atom:updated>2025-04-01T15:42:41.368Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GDIB6ulMySc1uixaYj3vtQ.jpeg" /></figure><p>The Coherence team is pleased to announce the availability of Coherence Community Edition (CE) release 25.03 today. Release 25.03 runs on Java 21 and 24. It is a non-LTS release that will be supported until the next CE release, 25.09 in September. Read on for highlights of exciting enhancements in CE 25.03 and also the recent Coherence Command Line Interface (CLI) release 1.9.0.</p><p>Elements of the release are:</p><ul><li><a href="https://github.com/oracle/coherence/releases/tag/25.03">Source code</a> on GitHub</li><li><a href="https://central.sonatype.com/artifact/com.oracle.coherence.ce/coherence-bom/25.03">Artifacts</a> on Maven Central</li><li><a href="https://github.com/oracle/coherence/pkgs/container/coherence-ce">Docker images</a> on GitHub</li><li><a href="https://docs.coherence.community/coherence/docs/25.03/docs/about/01_overview">Documentation</a> for 25.03</li></ul><p>Coherence CE 25.03 and Coherence CLI 1.9.0 bring the following exciting enhancements:</p><ul><li><strong>Topics support for remote Java clients </strong>— Ever since the initial release of the Topics messaging feature in Coherence, the clients publishing and receiving messages had to be Java components running in JVMs that were members of the Coherence cluster. Now in CE release 25.03, those Java clients can be remote from the Coherence cluster, connected to a proxy service in the cluster. In future CE releases, remote support will be provided in the Topics feature for other native language clients besides Java. These enhancements expand the applicability of the Topics feature to additional messaging use cases not previously possible with it. For more detail, see the <a href="https://docs.coherence.community/coherence/docs/25.03/docs/core/02_topics">documentation</a>.</li><li><strong>Create starter microservices projects with Coherence CLI</strong> — in addition to Coherence CE release 25.03, a new release 1.9.0 of the Coherence CLI project was just made. It offers a new command, cohctl create starter, which generates a Maven-based example starter microservices project using Coherence and either Helidon 4.2, Spring Boot 3.3, or Micronaut 4.8.9 (including Coherence integration with those microservices frameworks). The generated example projects demonstrate basic steps of integrating those microservice frameworks with Coherence to manage data used in a simple REST API. <a href="https://docs.coherence.community/coherence-cli/docs/latest/docs/reference/create_starter">This new command</a> promises to jumpstart developer productivity building Coherence-based microservices systems.</li><li><strong>JpaCacheLoader/JpaCacheStore classes moved</strong> —the classes JpaCacheLoader and JpaCacheStore have shipped with Coherence since the JPA specification was first released. However the source code of these classes was moved to the TopLink codebase when TopLink Grid was first released some 15 years ago. In Coherence CE 25.03 the source code of those classes is moved back into the Coherence codebase, in new package com.oracle.coherence.jpa in new Maven module coherence-jpa. This refactoring <a href="https://central.sonatype.com/artifact/com.oracle.coherence.ce/coherence-jpa">publishes</a> coherence-jpa build artifacts to Maven Central, and allows Coherence users to see that <a href="https://github.com/oracle/coherence/tree/v25.03/prj/coherence-jpa/src/main/java/com/oracle/coherence/jpa">source code</a> in GitHub.</li><li><strong>Removed use of </strong><strong>SecurityManager and </strong><strong>AccessController on Java 24</strong> — in Java 24, classes SecurityManager and AccessController are removed (they were deprecated in Java 17). Coherence CE 25.03 handles this with another refactoring, extracting the usages of SecurityManager into a utility class which is implemented twice in a multi-release jar. The implementation on Java 21 and earlier still uses SecurityManager, while the implementation on Java 24 and later doesn’t. Coherence security features are thus preserved, and users are unaffected, when running on Java 21 or 24.</li><li><strong>MBean operation and REST API for selectively resetting statistics</strong> — all Coherence MBeans support a resetStatistics() operation, which only resets statistics for that MBean. The Coherence REST API includes endpoints which reset statistics at broader scopes, but the coverage isn’t uniform. Now in Coherence CE 25.03 there is a REST API and a ManagementMBean operation resetStatistics(String queryString) where queryString is a JMX ObjectName query string. All Coherence MBeans returned by the JMX ObjectName query will have their individual resetStatistics() operations invoked by the implementation. The ability to easily reset Coherence MBean statistics at varying scopes greatly facilitates observability and problem diagnosis in test or even production environments.</li></ul><p>In addition to the above new features, CE 25.03 contains 15 other enhancements in the areas of configuration, ease-of-use, gRPC, observability, persistence, and Topics. It also contains 50 bug fixes. For a complete list of enhancements and fixes, please refer to the <a href="https://github.com/oracle/coherence/releases/tag/25.03">release notes</a>.</p><p>With support for remote Java clients for Topics messaging, and example starter project generation, as well as other enhancements, Coherence CE 25.03 and CLI 1.9.0 are more applicable and productive than ever for messaging and microservices use cases.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=146879b24a62" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/announcing-coherence-ce-25-03-and-coherence-cli-1-9-0-146879b24a62">Announcing Coherence CE 25.03 and Coherence CLI 1.9.0</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coherence for AI: CE 24.09 Is Here]]></title>
            <link>https://medium.com/oracle-coherence/coherence-for-ai-ce-24-09-is-here-5f71b7dec0ff?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/5f71b7dec0ff</guid>
            <category><![CDATA[microservice-architecture]]></category>
            <category><![CDATA[gen-ai-tools]]></category>
            <category><![CDATA[distributed-computing]]></category>
            <category><![CDATA[distributed-cache]]></category>
            <category><![CDATA[vector-database]]></category>
            <dc:creator><![CDATA[Randy Stafford]]></dc:creator>
            <pubDate>Fri, 27 Sep 2024 16:42:33 GMT</pubDate>
            <atom:updated>2025-06-06T02:50:23.361Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Hk52N_cx-QjzDrqY4cL2Q.jpeg" /></figure><p>We are fired up to announce the availability of Coherence Community Edition 24.09 today, featuring all-new vector database capabilities, and Retrieval Augmented Generation (<a href="https://www.oracle.com/artificial-intelligence/generative-ai/retrieval-augmented-generation-rag/">RAG</a>) application support capabilities, built on the world’s first and leading In-Memory Data Grid.</p><p>There is no doubt that Artificial Intelligence is one of the largest and fastest-moving technology waves to ever sweep through the software industry. Larry Ellison <a href="https://clouddb.substack.com/p/larry-ellison-on-oracle-database">opined</a> it is probably the most important technology in the history of IT.</p><p>Coherence has much to offer to RAG applications. Vector storage and search is just the foundation. That’s why in Community Edition release 24.09 we’ve decided to include fundamental vector database and RAG application support capabilities in the open-source core of all Coherence editions: to allow users to build on that base, and leverage other unique Coherence capabilities, in implementing RAG solutions of their own.</p><p>Coherence CE 24.09 runs on Java 21 and 17. It is a non-LTS release, supported until CE 25.03 is made next March. Elements of the release are:</p><ul><li><a href="https://github.com/oracle/coherence/releases/tag/24.09">Source code</a> on GitHub</li><li><a href="https://central.sonatype.com/artifact/com.oracle.coherence.ce/coherence">Artifacts</a> on Maven Central</li><li><a href="https://github.com/oracle/coherence/pkgs/container/coherence-ce">Docker images</a> on GitHub</li><li>Documentation for 24.09</li></ul><h3>Vector Database and RAG Application Support</h3><p>The vector database and RAG application support capabilities in CE 24.09 are implemented in a new package com.oracle.coherence.ai in the codebase’scoherence-core module. That package contains classes implementing Vectors of different types: BitVector, Float32Vector, Int8Vector. In RAG applications, instances of those classes are used as embeddings for document chunks, images, and other kinds of information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PqFyNea7NkeUyxn2-RBXkw.png" /></figure><p>Class com.oracle.coherence.ai.DocumentChunk models a chunk of a document used in a RAG application, and encapsulates a Float32Vector that is its embedding (computed by some <a href="https://www.nvidia.com/en-us/glossary/large-language-models/">Large Language Model</a> external to Coherence CE).</p><p>Layering on top ofDocumentChunks, or other application objects with vector embeddings, there is a SimilaritySearch class in the com.oracle.coherence.ai package, for querying the similarity between vector embeddings in different DocumentChunks or application objects, as is essential in RAG applications. SimilaritySearch is a Coherence <a href="https://medium.com/oracle-coherence/coherence-aggregator-deep-dive-a2de33c86aa4">Aggregator</a> that finds similar Vectors to a given one (e.g., an embedding of a user’s question in a RAG application), in parallel across a distributed cache spread over many machines or nodes, leveraging all available CPUs.</p><p>SimilaritySearch uses a com.oracle.coherence.ai.DistanceAlgorithm to compute the conceptual distance between Vectors. Implemented distance algorithms include CosineDistance, InnerProductDistance, and L2SquaredDistance. SimilaritySearch can leverage Coherence’s indexing capabilities, and the com.oracle.coherence.ai package includes a BinaryQuantIndex implementing <a href="https://huggingface.co/blog/embedding-quantization">binary quantization</a> of vector embeddings to speed similarity searches.</p><p>More importantly, CE 24.09 includes a Hierarchical Navigable Small World (<a href="https://ieeexplore.ieee.org/document/8594636">HNSW</a>) index implementation to optimize similarity search performance in Coherence. The implementation uses Java Native Access (<a href="https://github.com/java-native-access/jna">JNA</a>) to interact with the open source C++ <a href="https://github.com/nmslib/hnswlib">hnswlib</a>. Coherence’s HnswIndex implementation extends Coherence’s indexing framework and is therefore used in queries and aggregations of Vectors.</p><p>The SimilaritySearch Aggregator can be used in conjunction with other Coherence queries, to filter data before performing similarity searches on its embedded vectors.</p><p>Along with that foundation for vector storage and search, and RAG application support, the com.oracle.coherence.ai package adds framework supertypes, and library and utility classes, for RAG applications built on top of that base. Internal RAG applications at Oracle do that, for example.</p><p>Finally, the Coherence team has made contributions to LangChain4j and Spring AI, allowing CE 24.09 to be used as an EmbeddingStore and ChatMemoryStore in the former, and as a VectorStore in the latter.</p><h3>Other Improvements and Fixes in CE 24.09</h3><p>While the vector database and RAG application support capabilities are the major new feature in this release, a large number of other improvements and fixes have been made in the six months since the CE 24.03 release. Those improvements and fixes have been in the following areas:</p><h4><a href="https://docs.oracle.com/en/middleware/standalone/coherence/14.1.1.2206/develop-applications/implementing-concurreny-distributed-environment.html#GUID-E11A91A6-7F66-49E8-A9AE-2C2E56DF95CE">Coherence Concurrent</a></h4><ul><li>Introduced a distributed paged queue that does not have the 2GB size limit of the simple Coherence queue.</li><li>Added support to allow the definition of custom executors for the remote executor service via XML configuration.</li><li>Added support for advanced task orchestration across multiple JVMs via the RemoteExecutor API.</li><li>Added support for JDK 21 VirtualThread-per-task executors to the Coherence Executor Service.</li><li>Added cache backed implementations of java.util.Queue and Deque, and java.util.concurrent.BlockingQueue and BlockingDeque.</li></ul><h4>Serialization</h4><ul><li>Added support for high-performance (raw) serialization of primitive arrays and improved deserialization performance of very large byte arrays (&gt; 100MB).</li><li>Added support for serializing Protobuf messages using Coherence’s native Portable Object Format (POF) mechanism.</li><li>Added support for use of Java records as portable types.</li><li>The coherence-json module’s POF configuration file is now auto discoverable when using POF serialization.</li><li>Added support for the use of final fields within portable types.</li></ul><p>For a complete list of all improvements and fixes in the CE 24.09 release, see the <a href="https://github.com/oracle/coherence/releases/tag/24.09">release notes</a>.</p><h3>Summary</h3><p>With its vector database and RAG application support capabilities, 24.09 is an exciting release of Community Edition, positioning Coherence to add significant value to the explosion of RAG applications being developed everywhere all of a sudden. So take the red pill, and build your next RAG application with Coherence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TUMdbga7elSeI5bL1-beCA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f71b7dec0ff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/coherence-for-ai-ce-24-09-is-here-5f71b7dec0ff">Coherence for AI: CE 24.09 Is Here</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Say Hello to Coherence Community Edition 24.03!]]></title>
            <link>https://medium.com/oracle-coherence/say-hello-to-coherence-community-edition-24-03-e5db336167f2?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/e5db336167f2</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[imdg]]></category>
            <category><![CDATA[coherence]]></category>
            <dc:creator><![CDATA[Randy Stafford]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 15:04:45 GMT</pubDate>
            <atom:updated>2025-06-06T02:51:12.740Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Galaxy NGC 2403 in the constellation Camelopardalis" src="https://cdn-images-1.medium.com/max/600/1*lmYTTVMu6vF_HHdnvCd1wA.jpeg" /><figcaption>Galaxy NGC 2403 in the constellation Camelopardalis</figcaption></figure><p>The Coherence team is pleased to announce the availability of Coherence Community Edition (CE) release 24.03 today, compatible with Helidon 4, supporting Java 21 and 17, and containing a number of enhancements and fixes. This is a non-LTS release, supported until the next Community Edition release, 24.09 in September.</p><p>Elements of the release are:</p><ul><li><a href="https://github.com/oracle/coherence/releases/tag/24.03">Source code</a> on GitHub</li><li><a href="https://central.sonatype.com/artifact/com.oracle.coherence.ce/coherence">Artifacts</a> on Maven Central</li><li><a href="https://github.com/oracle/coherence/pkgs/container/coherence-ce">Docker images</a> on GitHub</li><li><a href="https://docs.coherence.community/coherence/docs/latest/docs/about/01_overview">Documentation</a> for 24.03</li></ul><p>Coherence CE 24.03 contains the following new features:</p><ul><li><strong>Compatibility with Helidon 4 </strong>— released in late October 2023, <a href="https://medium.com/helidon/helidon-4-is-released-a06756e1562a">Helidon 4</a> is the first microservice framework rebuilt from scratch on <a href="https://www.oracle.com/news/announcement/ocw-oracle-releases-java-21-2023-09-19/">Java 21</a> <a href="https://openjdk.org/jeps/444">virtual threads</a>. Coherence and Helidon have been closely integrated since the launch of Coherence CE four years ago, <a href="https://medium.com/helidon/flying-as-a-flock-helidon-and-coherence-integration-in-oracle-banking-cloud-services-862f9babbb66">enabling productive development of high-scale stateful microservices</a>. We are thrilled to announce a version of Coherence CE compatible with this groundbreaking latest version of Helidon.</li><li><strong>Support for OpenTelemetry</strong> — Coherence CE already <a href="https://medium.com/oracle-coherence/peek-inside-coherence-with-opentracing-dcdd6906dec8">supported</a> distributed tracing when it was launched in June 2020. That support was initially based on the OpenTracing project and APIs. Since the Cloud Native Computing Foundation archived the OpenTracing project two years ago in favor of its OpenTelemetry project, Coherence CE 24.03 <a href="https://coherence.community/latest/24.03/docs/#/docs/core/11_otel">adds support</a> for OpenTelemetry (and retains support for OpenTracing).</li><li><strong>Query performance optimizations</strong> — the Coherence product architects and engineering team invested in improving the performance of certain Coherence queries and other filtered operations for the 24.03 release, and the results are significant. The improvements leverage partitioned indexes to parallelize query execution within storage members. Tests show substantial execution time reductions for certain operations.</li><li><strong>Partition-level statistics</strong> — a new operation on StorageManager MBean returns the entry count and data size in memory per partition for the cache, service, and member managed. This level of data, from the important concept of partitions in Coherence, enhances the observability of Coherence in user applications.</li><li><strong>Distributed </strong><strong>BlockingQueues</strong> — in an enhancement to the coherence-concurrent module, i.e. Coherence-backed implementations of java.util.concurrent types, CE 24.03 introduces implementations of java.util.Queue and Deque, and java.util.concurrent.BlockingQueue and BlockingDeque. These new cache-backed implementations further enhance Coherence’s ability to support process coordination through the grid.</li></ul><p>In addition to the above new features, CE 24.03 contains a dozen other more minor enhancements in the areas of performance, observability, Gradle support, and ease of use. It also contains 59 bug fixes. For a complete list of enhancements and fixes, please refer to the <a href="https://github.com/oracle/coherence/releases/tag/24.03">release notes</a>.</p><p>With support for Helidon 4, and important observability and performance improvements, Coherence CE 24.03 is ready to take on your most demanding stateful microservices projects.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5db336167f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/say-hello-to-coherence-community-edition-24-03-e5db336167f2">Say Hello to Coherence Community Edition 24.03!</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to get the Top N most accessed keys in a Coherence cache?]]></title>
            <link>https://medium.com/oracle-coherence/how-to-get-the-top-n-most-accessed-keys-in-a-coherence-cache-07113b591f4e?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/07113b591f4e</guid>
            <category><![CDATA[in-memory-cache]]></category>
            <category><![CDATA[oracle-coherence]]></category>
            <category><![CDATA[caching]]></category>
            <dc:creator><![CDATA[Jplaroche ]]></dc:creator>
            <pubDate>Thu, 21 Mar 2024 21:24:20 GMT</pubDate>
            <atom:updated>2024-07-23T17:00:20.035Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*63MCyJQOzAOQhTUE6XLG6Q.png" /></figure><p>Ever had to figure out what are the most accessed entries (hot keys) in an Oracle Coherence<strong> </strong>cache?</p><p>There are multiple ways to do this in Coherence, but there is a lesser known way (to me at least) to do it by leveraging readily available internal cache content tracking attributes within Coherence.</p><p>Let’s say you work for a wireless company and you are caching price plans for a speedy response time on their retail website. Upper management needs to know what price plans are the most requested and also keep track of the top 10 price plans on a daily basis.</p><p>One straightforward approach would be to track for each cache item a counter, and every time you access an item, you would increment the corresponding counter (and keep it in another specific cache). But you would need, in addition to the original price plan cache read, one read + one write access for the tracking counter. Alternatively you could decide to keep the counter within the price plan entity, but then things would be even worse since you would be making a read then a write for each price plan request. Remember, writes are slower than reads.</p><p>The better way is to fetch the internal touch count associated to a <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/cache/OldCache.Entry.html#getTouchCount--">local cache entry</a>. This assumes that your cache is configured to use a local cache as its backing map.</p><pre>&lt;cache-config&gt;<br><br>  &lt;caching-scheme-mapping&gt; <br>    &lt;cache-mapping&gt;<br>      &lt;cache-name&gt;PricePlan&lt;/cache-name&gt;<br>      &lt;scheme-name&gt;PricePlanScheme&lt;/scheme-name&gt;<br>    &lt;/cache-mapping&gt;<br>  &lt;/caching-scheme-mapping&gt;<br><br>  &lt;caching-schemes&gt; <br>    &lt;distributed-scheme&gt;<br>      &lt;scheme-name&gt;PricePlanScheme&lt;/scheme-name&gt;<br>      &lt;service-name&gt;PricePlanCacheService&lt;/service-name&gt;<br>      &lt;backing-map-scheme&gt;<br>        &lt;local-scheme&gt;<br>          &lt;expiry-delay&gt;10d&lt;/expiry-delay&gt;<br>        &lt;/local-scheme&gt;<br>      &lt;/backing-map-scheme&gt;<br>      &lt;autostart&gt;true&lt;/autostart&gt;<br>    &lt;/distributed-scheme&gt;<br>  &lt;/caching-schemes&gt;<br><br>&lt;/cache-config&gt;</pre><p>Coherence internally keeps track of how many times an entry is touched (read or write). It needs that to manage cache eviction. You can read more about it <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/develop-applications/cache-configurations-example.html#GUID-3A02103F-0DBF-47B2-A940-9EDD928E45C5">here</a>; to support the least frequently used eviction policy, Coherence internally keeps track of the number of times each cache entry is accessed.</p><p>So how are we going to fetch this value for each cache entry in the backing map and, better, figure out only the top N hot keys?</p><p>We will first need to visit each backing map of this cache, on each storage member (since we are using a partitioned cache). For this we will use an <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/Invocable.html">I</a><a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/Invocable.html"><strong>nvocable</strong></a> (HotKeyInvocable) through an <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/InvocationService.html">I</a><a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/InvocationService.html"><strong>nvocationService</strong></a> (InvocationService-TouchCount), to be added to your cache configuration:</p><pre>&lt;invocation-scheme&gt;<br>  &lt;scheme-name&gt;invocation-service&lt;/scheme-name&gt;<br>  &lt;service-name&gt;InvocationService-TouchCount&lt;/service-name&gt;<br>  &lt;autostart&gt;true&lt;/autostart&gt;<br>&lt;/invocation-scheme&gt;</pre><p>Here is what the run() method of this invocation handler looks like:</p><pre>/**<br> * Fetches the touch count of each entry of the backing map.<br> */<br>public void run() <br>    {<br>    SortedCollectionWithCapacity&lt;HotKeyData&lt;K&gt;&gt; results = <br>        new SortedCollectionWithCapacity&lt;HotKeyData&lt;K&gt;&gt;(this.topN);<br><br>    DistributedCacheService cacheService =<br>        (DistributedCacheService) CacheFactory.getService(cacheServiceName);<br>    Member localMember = cacheService<br>        .getCluster()<br>        .getLocalMember();<br>    int localMemberId = localMember.getId();<br>    Set backingMapEntries = cacheService<br>        .getBackingMapManager()<br>        .getContext()<br>        .getBackingMap(cacheName)<br>        .entrySet();<br>    BackingMapContext backingMapContext = cacheService<br>        .getBackingMapManager()<br>        .getContext()<br>        .getBackingMapContext(cacheName);<br>    Converter converter = backingMapContext<br>        .getManagerContext()<br>        .getKeyFromInternalConverter();<br><br>    for (Object entry : backingMapEntries) <br>        {<br>        LocalCache.Entry localCacheEntry = (LocalCache.Entry) entry;<br>        K key = (K) converter.convert(localCacheEntry.getKey());<br>        results.add(new HotKeyData&lt;K&gt;(key, localCacheEntry.getTouchCount()));<br>        }<br><br>    this.setResult(results);<br>    }</pre><p>We are accumulating the partial results in a custom structure SortedCollectionWithCapacity<strong> </strong>to keep the top N keys in a sorted order (not discussed here, but bundled in the source code). The rest of the code is about how to retrieve the valuable touch count from the backing map.</p><p><em>Caveat: this assumes that the backing map’s direct implementation is a com.tangosol.net.cache.LocalCache, if you use a backing map like a read write backing map, then you will need to access the internal cache from the backing map to get the entries as LocalCache.Entry. Something like ((com.tangosol.net.cache.ReadWriteBackingMap) backingMapContext.getBackingMap()).getInternalCache().entrySet().</em></p><p>We will run this Invocable against each storage node owning the the targeted cache service. Here is how we will invoke it:</p><pre>// we will gather each result per member in this structure<br>// see InvocationObserver.memberCompleted<br>Map&lt;Member, SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt;&gt; invocationResults =<br>    new HashMap&lt;Member, SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt;&gt;();<br><br>DistributedCacheService distributedCacheService = <br>    (DistributedCacheService) CacheFactory.getService(&quot;PricePlanCacheService&quot;);<br>Set&lt;Member&gt; storageMembers = <br>    distributedCacheService.getOwnershipEnabledMembers();<br>InvocationService is = <br>    (InvocationService) CacheFactory.getService(&quot;InvocationService-TouchCount&quot;);<br><br>InvocationObserver observer = <br>    newInvocationObserver(countDownLatch, startTime, isVerbose());<br><br>for (Member member : storageMembers) <br>    {<br>    HotKeyInvocable&lt;Integer&gt; invocable = <br>        new HotKeyInvocable&lt;Integer&gt;(getCacheName(), <br>            getCacheServiceName(), <br>            getTopN());<br>    is.execute(invocable, Collections.singleton(member), observer);<br>    }<br></pre><p>Note that we need to register an <a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/InvocationObserver.html">I</a><a href="https://docs.oracle.com/en/middleware/fusion-middleware/coherence/12.2.1.4/java-reference/com/tangosol/net/InvocationObserver.html"><strong>nvocationObserver</strong></a><strong> (</strong>com.tangosol.net.InvocationObserver<strong>) </strong>to gather the execution result from each member once the local invocation completes:</p><pre>/**<br>  * Create and return an InvocationObserver for observing <br>  * the progress of asynchronous Invocable execution.<br>  */<br>private InvocationObserver newInvocationObserver(final CountDownLatch countDownLatch, final long startTime, final boolean isVerbose)<br>    {<br>    return new InvocationObserver()<br>        {<br>        public void memberCompleted(Member member, Object result)<br>            {<br>            invocationResults.put(member, <br>                (SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt;) result);<br>            countDownLatch.countDown();<br>            CacheFactory.log(String.format(&quot;Task completed on %s.&quot;, member));<br>            }<br><br>        public void memberFailed(Member member, Throwable throwable)<br>            {<br>            invocationResults.put(member, null);<br>            countDownLatch.countDown();<br>            CacheFactory.log(String.format(&quot;Task failed on %s.&quot;, member));<br>            CacheFactory.log(throwable);<br>            }<br>        public void memberLeft(Member member)<br>            {<br>            invocationResults.put(member, null);<br>            countDownLatch.countDown();<br>            CacheFactory.log(String.format(&quot;Member left before task completed: %s&quot;, member));<br>            }<br><br>        public void invocationCompleted()<br>            {<br>            CacheFactory.log(&quot;invocation completed&quot;);<br>            }<br>        };<br>    }</pre><p>Once all the Invocables have completed, we can access the results from each member, merge them (through the SortedCollectionWithCapacity class), and collect the final top N most accessed keys:</p><pre>SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt; mergedResult =<br>    new SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt;(getTopN());<br><br>for (Map.Entry&lt;Member, SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt;&gt; entry : invocationResults.entrySet())<br>    {<br>    Member member = entry.getKey();<br>    if (entry.getValue() != null) <br>        {<br>        SortedCollectionWithCapacity&lt;HotKeyData&lt;Integer&gt;&gt; result = <br>            entry.getValue();<br>        mergedResult.merge(result);<br>        }<br>    }</pre><p>This source code and a running example is available <a href="https://github.com/jplaroche2000/coherence-hotkeys">here</a>.</p><p>Here is a sample execution output:</p><p>(Coherence 12.2.1.4.20, 3 storage nodes, 1 million entries, top 3 hot keys)</p><pre>Execution on member Member(Id2, Address=127.0.0.1:9002, Role=cache-server) took 106 ms<br>Execution on member Member(Id1, Address=127.0.0.1:9001, Role=cache-server) took 117 ms<br>Execution on member Member(Id3, Address=127.0.0.1:9003, Role=cache-server) took 113 ms<br>Total gathering of top 3 hot keys took 150 ms<br>SortedCollectionWithCapacity [sortedSet=[[key=50, touchCount=50], [key=25, touchCount=25], [key=10, touchCount=10]], maxCapacity=3]</pre><p>I hope this efficient way of finding and reporting the top N hot keys in Coherence caches proves useful to other Coherence users, some of whom have <a href="https://github.com/oracle/coherence/issues/110">asked</a> about such solutions.</p><p><em>Note from editors: we are pleased to publish this solution story from a longtime leading Coherence user in the community. If you’re reading this and have your own idea on a cool solution trick you’d like to share with the community of Coherence users, please do reach out to the editors of this publication.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=07113b591f4e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/how-to-get-the-top-n-most-accessed-keys-in-a-coherence-cache-07113b591f4e">How to get the Top N most accessed keys in a Coherence cache?</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Using Coherence to manage HTTP sessions in Go]]></title>
            <link>https://medium.com/oracle-coherence/using-coherence-to-manage-http-sessions-in-go-6aa0c71201ff?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/6aa0c71201ff</guid>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[middleware]]></category>
            <category><![CDATA[sessionstorage]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Tim Middleton]]></dc:creator>
            <pubDate>Thu, 04 Jan 2024 17:27:27 GMT</pubDate>
            <atom:updated>2024-05-17T06:44:28.318Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Oracle Coherence and Golong" src="https://cdn-images-1.medium.com/max/1024/1*Id_T3n023bcyE6rDrnMAuQ.png" /></figure><h3>Introduction</h3><p>A few months ago we <a href="https://medium.com/oracle-coherence/the-coherence-go-client-6750513ccbe1">announced</a> the Coherence Go client, allowing native Go applications to access the <a href="https://github.com/oracle/coherence">Coherence</a> data grid.</p><p>Today we would like to announce that your Go applications can now <strong>use Coherence as an HTTP session </strong>store via integration with the very popular “Express inspired web framework” <strong>Fiber. (</strong><a href="https://github.com/gofiber/fiber">https://github.com/gofiber/fiber</a>)</p><p>In this article we will walk through creating a simple Fiber based web app which will store and retrieve HTTP sessions using a <a href="https://github.com/oracle/coherence">Coherence Community Edition</a> (CE) cluster.</p><figure><img alt="Fiber icon" src="https://cdn-images-1.medium.com/max/848/1*Nxy3evGW8R69wwNpTES6jg.png" /></figure><h3>Why use Coherence for session storage?</h3><p><a href="http://coherence.community/">Coherence</a> is a scalable, fault-tolerant, cloud-ready, distributed platform for building grid-based applications and reliably storing data.</p><p>Using Coherence for session management provides <strong>a scalable and fault-tolerant session store </strong>allowing sessions to “fail-over” to surviving nodes if you have a server outage on the middle-tier or the Coherence storage-tier. It also allows you to easily scale your session storage-tier as your demand or load increases.</p><p>To demonstrate this best in a demo environment, we will create our environment using <em>Docker Compose </em>and configure a <a href="https://github.com/traefik/traefik/">Traefik</a> load balancer in front of a 2 node Coherence cluster to demonstrate the failover capabilities.</p><p>The Go Fiber session management uses Coherence as the store and connects to the Coherence cluster via the load balancer balancer using <a href="https://grpc.io/"><em>gRPC</em></a>. Coherence automatically creates a backup of all objects on separate nodes to ensure fault-tolerance.</p><figure><img alt="Diagram of a web browser accessing a Go application which connects to load balancer in front of two Coherence cluster members." src="https://cdn-images-1.medium.com/max/1024/1*OlZ2Jr5ZPT9Hjjk2fcDRCA.png" /></figure><h3>Pre-requisites</h3><p>To get started, ensure you have the following:</p><ol><li>Docker setup using either Docker or Rancher Desktop</li><li>Go 1.19 or above</li><li>Your favourite IDE</li></ol><h3>Create a new Go project</h3><p>Open a terminal and create a directory for your example, and initialize using:</p><pre>mkdir go-sessions<br>cd go-sessions<br>go mod init main</pre><p>Download v2 of <strong>fiber:</strong></p><pre>go get github.com/gofiber/fiber/v2@latest</pre><p>Download the Coherence storage driver for <strong>fiber:</strong></p><pre>go get github.com/gofiber/storage/coherence@latest</pre><blockquote>Note: This driver is an implementation using v1.0.3 of the <a href="https://github.com/oracle/coherence-go-client">Coherence Go Client</a>.</blockquote><h3>Start a Coherence Cluster</h3><p>You can use a commercial (14.1.1.2206.5+) or Community Edition (CE) 22.06.5+ Coherence cluster configured with a <a href="https://docs.oracle.com/en/middleware/standalone/coherence/14.1.1.2206/develop-remote-clients/using-coherence-grpc-server.html#GUID-921D7726-BF90-45EF-9BF2-CC7B1CADFDB5">gRPC proxy server</a>.</p><p>You can choose to create a single member cluster just to see this in action, or a load balanced cluster to show the best use case for Coherence sessions.</p><h4>Start a load balanced cluster</h4><p>Create a file called <strong>docker-compose.yaml</strong> in the <strong>go-sessions</strong> directory with the following content:</p><pre>version: &quot;3.5&quot;<br>services:<br>  grpc-proxy:<br>    depends_on:<br>      - coherence1<br>      - coherence2<br>    image: traefik:latest<br>    command: --api.insecure=true --providers.docker --entrypoints.other.address=:1408  --log.level=DEBUG<br>    ports:<br>      - &quot;8080:8080&quot;<br>      - &quot;1408:1408&quot;<br>    volumes:<br>      - /var/run/docker.sock:/var/run/docker.sock<br>    networks:<br>      coherence:<br>        aliases:<br>          - proxy<br><br>  coherence1:<br>    hostname: machine1<br>    networks:<br>      coherence:<br>        aliases:<br>          - machine1<br>    image: ghcr.io/oracle/coherence-ce:23.03.1<br>    environment:<br>      - coherence.cluster=cluster1<br>      - coherence.member=member1<br>      - coherence.machine=machine1<br>      - coherence.wka=machine1<br>      - coherence.health.http.port=6676<br>      - coherence.management.http=all<br>    ports:<br>      - 30000:30000<br>    labels:<br>      - &quot;traefik.enable=true&quot;<br>      - &quot;traefik.TCP.Routers.coherence2.Rule=HostSNI(`*`)&quot;<br>      - &quot;traefik.TCP.Services.coherence2.LoadBalancer.server.Port=1408&quot;<br>      - &quot;traefik.http.services.coherence2.loadbalancer.healthcheck.path=/ready&quot;<br>      - &quot;traefik.http.services.coherence2.loadbalancer.healthcheck.port=6676&quot;<br><br>  coherence2:<br>    hostname: machine2<br>    networks:<br>      coherence:<br>        aliases:<br>          - machine2<br>    image: ghcr.io/oracle/coherence-ce:23.03.1<br>    environment:<br>      - coherence.cluster=cluster1<br>      - coherence.member=member2<br>      - coherence.machine=machine1<br>      - coherence.health.http.port=6676<br>      - coherence.wka=machine1<br>      - coherence.management=all<br>    labels:<br>      - &quot;traefik.enable=true&quot;<br>      - &quot;traefik.TCP.Routers.coherence2.Rule=HostSNI(`*`)&quot;<br>      - &quot;traefik.TCP.Services.coherence2.LoadBalancer.server.Port=1408&quot;<br>      - &quot;traefik.http.services.coherence2.loadbalancer.healthcheck.path=/ready&quot;<br>      - &quot;traefik.http.services.coherence2.loadbalancer.healthcheck.port=6676&quot;<br><br>networks:<br>  coherence:</pre><p>The above yaml creates three services.</p><ul><li>A <strong>grpc-proxy, — </strong>Traefik load balancer on port 1408 (the default Coherence gRPC port) load balancing to the cluster members</li><li><strong>coherence1</strong> — Coherence member 1 with management enabled on port 30000 and gRPC listing on default port of 1408</li><li><strong>coherence2</strong> — Coherence member1 with gRPC listening on default port of 1408</li></ul><p>Start the environment by issuing the following command from the<strong> go-sessions</strong> directory:</p><pre>docker compose up -d</pre><p>To check that the Coherence cluster is ready using docker ps and ensure the STATUS of the coherence cluster members show <strong>healthy</strong>.</p><h3>Create the code</h3><p>In this simple session example we are providing 2 HTTP endpoints:</p><ol><li><strong>/</strong> — will create or load the existing session and store a count of how many times this endpoint has been called as well as first and last access time</li><li><strong>/destroy</strong> — will simulate a “logout” function and destroy the current session and force a new one to be created on next access</li></ol><p>We will add the code in sections to explain each of the parts. (The full code listing is below if you want to just copy/ paste)</p><p>With your IDE, create a new file main.go and add the following package and imports and global variables.</p><pre>package main<br><br>import (<br>    &quot;fmt&quot;<br>    &quot;github.com/gofiber/fiber/v2&quot;<br>    &quot;github.com/gofiber/fiber/v2/middleware/session&quot;<br>    &quot;github.com/gofiber/storage/coherence&quot;<br>    &quot;log&quot;<br>    &quot;strings&quot;<br>    &quot;time&quot;<br>)<br><br>var store *session.Store  // gofiber session store</pre><p>Continuing editing the same file, create the main function, which will:</p><ol><li>Create a new Coherence store to be used by the Fiber session store</li><li>Intialize the fiber session store with the Coherence store and set the HTTP expiry to 120 seconds</li><li>Create a new fiber app</li></ol><pre>func main() {<br>    // create new coherence session store using defaults of localhost:1408<br>    storage, err := coherence.New()<br>    if err != nil {<br>         log.Fatal(&quot;unable to connect to Coherence &quot;, err)<br>    }<br>    defer storage.Close()<br><br>    // initialize the gofiber session store using the Coherence storage driver<br>    store = session.New(session.Config{<br>        Storage:    storage,<br>        Expiration: time.Duration(120) * time.Second,<br>    })<br><br>    app := fiber.New()</pre><p>Create a route for the/resource, which will:</p><ol><li>Retrieve the session from the store, which under the hood checks Coherence</li><li>If the session is new (fresh) then set session attributes accessCount and firstAccess</li><li>If the session is an existing session, then increment the accessCount and update lastAccess</li><li>Display the current set of HTTP session values</li></ol><pre> app.Get(&quot;/&quot;, func(c *fiber.Ctx) error {<br>     // retrieve the session<br>     sess, err1 := store.Get(c)<br>     if err1 != nil {<br>         return c.Status(500).SendString(err1.Error())<br>    }<br><br>    if sess.Fresh() {<br>        // new session<br>        sess.Set(&quot;accessCount&quot;, 1)<br>        sess.Set(&quot;firstAccess&quot;, time.Now().Format(time.ANSIC))<br>    } else {<br>        // increment the number of times we have hit this endpoint<br>       count := sess.Get(&quot;accessCount&quot;).(int)<br>       count++<br>       sess.Set(&quot;accessCount&quot;, count)<br>       sess.Set(&quot;lastAccess&quot;, time.Now().Format(time.ANSIC))<br>    }<br><br>    var sb strings.Builder<br><br>    sb.WriteString(fmt.Sprintf(&quot;Session: %s, new=%v\nSession values:\n&quot;, sess.ID(), sess.Fresh()))<br>    for _, k := range sess.Keys() {<br>        sb.WriteString(fmt.Sprintf(&quot;   %s=%v\n&quot;, k, sess.Get(k)))<br>    }<br><br>    if err1 = sess.Save(); err1 != nil {<br>        return c.Status(500).SendString(err1.Error())<br>    }<br>    return c.SendString(sb.String())<br> })</pre><p>Create a route for the /destroy endpoint, which will remove the session and finally, listen on port :2000.</p><pre><br>    app.Get(&quot;/destroy&quot;, func(c *fiber.Ctx) error {<br>       // retrieve the session<br>       sess, err1 := store.Get(c)<br>       if err1 != nil {<br>           return c.Status(500).SendString(err1.Error())<br>       }<br>       id := sess.ID()<br><br>       // remove the session<br>       err1 = sess.Destroy()<br>       if err1 != nil {<br>           return c.Status(500).SendString(err1.Error())<br>        }<br>        return c.Status(200).SendString(fmt.Sprintf(&quot;session %v destroyed&quot;, id))<br>    })<br><br>    panic(app.Listen(&quot;127.0.0.1:2000&quot;))<br>}</pre><h3>Run the Fiber application</h3><p>Run the code example via executing go run main.go. You should see the following output indicating that fiber is up and running and the Coherence session is connected.</p><pre>go run main.go <br><br>2023/08/30 11:26:29 session: 29baf94f-efb5-4d65-b6f3-cb4c39f4d87a connected to address localhost:1408<br><br> ┌───────────────────────────────────────────────────┐ <br> │                   Fiber v2.49.0                   │ <br> │               http://127.0.0.1:2000               │ <br> │                                                   │ <br> │ Handlers ............. 4  Processes ........... 1 │ <br> │ Prefork ....... Disabled  PID ............. 25016 │ <br> └───────────────────────────────────────────────────┘ </pre><h3>Testing basic access</h3><p>Open up a Web browser (Safari in my case), and go to the url <a href="http://127.0.0.1:2000/">http://127.0.0.1:2000</a>. You should see something similar to the following indicating that a new session has been created.</p><figure><img alt="Initiall access to root URL where a new session is created" src="https://cdn-images-1.medium.com/max/767/1*F6eNvKezvQU6FYJS0Abvqw.png" /></figure><p>Refresh the URL a couple of times and you will see that the session is no longer new and the accessCount has been updated.</p><figure><img alt="session variable supdated after subsequent access" src="https://cdn-images-1.medium.com/max/767/1*ZW_4k-NTJ_N2BhgKFVXsGg.png" /></figure><p>Finally access the url <a href="http://127.0.0.1:2000/destroy">http://127.0.0.1:2000/destroy</a> which will destroy the session.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/1*682-jTufDOXPxihUG8u-1g.png" /></figure><blockquote>You can also wait for longer 120 seconds and then when you refresh the browser you will see that the session has expired and a new one has been created.</blockquote><h3>Testing failover</h3><p>To show failover of sessions, we must first determine which Coherence node is storing the session so we can kill that node to simulate fail-over.</p><blockquote>Normally we don’t care about knowing this as Coherence will create a primary and a backup on different nodes by default.</blockquote><p>Making sure that you have refreshed the browser a few times to ensure your session is still valid for 120 seconds, issue the following two commands to query Coherence management to show you which node owns the data.</p><pre>curl -s http://127.0.0.1:30000/management/coherence/cluster/caches/fiber%24default-store/members/1?tier=back | jq | egrep &#39;size&#39;<br>curl -s http://127.0.0.1:30000/management/coherence/cluster/caches/fiber%24default-store/members/2?tier=back | jq | egrep &#39;size&#39;</pre><p>The output should be something similar to the following, which in our case means that member with <strong>Id=2</strong> is holding the session.</p><pre>curl -s http://127.0.0.1:30000/management/coherence/cluster/caches/fiber%24default-store/members/1?tier=back | jq | egrep &#39;size&#39;<br>      &quot;size&quot;: 0,<br>curl -s http://127.0.0.1:30000/management/coherence/cluster/caches/fiber%24default-store/members/2?tier=back | jq | egrep &#39;size&#39;<br>      &quot;size&quot;: 1,</pre><p>We then need to determine which member is member <strong>Id=2</strong>, as it may be either of the coherence1 or coherence2 nodes. We issue the curl against member/2 path.</p><pre>curl -s http://127.0.0.1:30000/management/coherence/cluster/members/2 | jq | grep machineName<br>  &quot;machineName&quot;: &quot;machine1&quot;,</pre><blockquote>Refresh your browser a few more times to ensure your session has not expired while carrying out the above.</blockquote><p>In our case the container is <strong>machine1</strong>, so we issue a docker ps to find the container Id matching <strong>go-sessions-coherence1–1.</strong></p><p>Issue the docker kill against the container you identified.</p><p><strong>Refresh your browser again and you should see the </strong><strong>accessCount has been incremented and the session is not new. This means that the session data failed over to the surviving Coherence node.</strong></p><p>On the terminal where you started the main.go you may see the following message if the container you killed was the one that your gRPC session was connected to.</p><p>The fact that the gRPC connection goes to a particular container does not mean Coherence will store data there, Coherence balances the data across available storage-nodes.</p><pre><br>2023/09/06 15:09:18 event stream recv failed: rpc error: code = Unavailable desc = error reading from server: EOF<br>2023/09/06 15:09:18 session: 9e4dd87e-1d7f-491d-a217-d2e536815987 disconnected from address localhost:1408<br>2023/09/06 15:09:19 session: 9e4dd87e-1d7f-491d-a217-d2e536815987 re-connected to address localhost:1408<br></pre><h3>Additional tests</h3><p>To further explore the example, you can try the following:</p><ol><li>After refreshing the URL a number of times, wait for longer than 120 seconds, the configured session timeout, and then access the URL again. You will see the the session is now <strong>new</strong> again (due to the session expiry), and the accessCount is back to one.</li><li>Open a second browser, say Firefox, and access the same URL. You will see that a different session is created due to the different browser. These sessions are independent from each other and stored accordingly in the Coherence cluster.</li></ol><h3>Conclusion</h3><p>The above is only a simple example, but you can see how easy it is to store your HTTP session in Coherence to provide session failover and leverage the scalability, availability, reliability, and performance for in-memory session management and storage.</p><p>For more information see the following:</p><ul><li><a href="https://github.com/gofiber/storage/tree/main/coherence">Coherence storage driver for Fiber on GitHub</a></li><li><a href="https://github.com/gofiber/fiber">Fiber on GitHub</a></li><li><a href="https://github.com/oracle/coherence-go-client">Coherence Go client on GitHub including extensive examples</a></li><li><a href="https://coherence.community/">Learn about the Coherence data grid on the Coherence Communit</a>y</li></ul><h3>Full code listing</h3><p>For convenience, the full code listing is below.</p><p>Note: You can access the code here — <a href="https://github.com/tmiddlet2666/coherence-playground/tree/main/go/sessions">https://github.com/tmiddlet2666/coherence-playground/tree/main/go/sessions</a></p><pre>package main<br><br>import (<br>    &quot;fmt&quot;<br>    &quot;github.com/gofiber/fiber/v2&quot;<br>    &quot;github.com/gofiber/fiber/v2/middleware/session&quot;<br>    &quot;github.com/gofiber/storage/coherence&quot;<br>    &quot;log&quot;<br>    &quot;strings&quot;   <br>    &quot;time&quot;<br>)<br><br>var store *session.Store<br><br>func main() {<br>    // create new coherence session store using defaults of localhost:1408<br>    storage, err := coherence.New()<br>    if err != nil {<br>        log.Fatal(&quot;unable to connect to Coherence &quot;, err)<br>    }<br>    defer storage.Close()<br><br>    // initialize the gofiber session store using the Coherence storage driver<br>    store = session.New(session.Config{<br>        Storage:    storage,<br>        Expiration: time.Duration(120) * time.Second,<br>    })<br><br>    app := fiber.New()<br><br>    app.Get(&quot;/&quot;, func(c *fiber.Ctx) error {<br>        // retrieve the session<br>        sess, err1 := store.Get(c)<br>        if err1 != nil {<br>            return c.Status(500).SendString(err1.Error())<br>         }<br><br>        if sess.Fresh() {<br>            // new session<br>            sess.Set(&quot;accessCount&quot;, 1)<br>            sess.Set(&quot;firstAccess&quot;, time.Now().Format(time.ANSIC))<br>        } else {<br>            // increment the number of times we have hit this endpoint<br>            count := sess.Get(&quot;accessCount&quot;).(int)<br>            count++<br>            sess.Set(&quot;accessCount&quot;, count)<br>            sess.Set(&quot;lastAccess&quot;, time.Now().Format(time.ANSIC))<br>        }<br><br>        var sb strings.Builder<br><br>        sb.WriteString(fmt.Sprintf(&quot;Session: %s, new=%v\nSession values:\n&quot;, sess.ID(), sess.Fresh()))<br>        for _, k := range sess.Keys() {<br>            sb.WriteString(fmt.Sprintf(&quot;   %s=%v\n&quot;, k, sess.Get(k)))<br>        }<br><br>        if err1 = sess.Save(); err1 != nil {<br>           return c.Status(500).SendString(err1.Error())<br>        }<br>        return c.SendString(sb.String()) <br>   })<br><br>   app.Get(&quot;/destroy&quot;, func(c *fiber.Ctx) error {<br>       // retrieve the session<br>       sess, err1 := store.Get(c)<br>       if err1 != nil {<br>          return c.Status(500).SendString(err1.Error())<br>       }<br>       id := sess.ID()<br><br>       // remove the session<br>       err1 = sess.Destroy()<br>       if err1 != nil {<br>           return c.Status(500).SendString(err1.Error())<br>       }<br>       return c.Status(200).SendString(fmt.Sprintf(&quot;session %v destroyed&quot;, id))   <br>    })<br><br>    panic(app.Listen(&quot;127.0.0.1:2000&quot;))<br>}</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6aa0c71201ff" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/using-coherence-to-manage-http-sessions-in-go-6aa0c71201ff">Using Coherence to manage HTTP sessions in Go</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coherence Spring 4.1.0 & 3.3.4 Released]]></title>
            <link>https://medium.com/oracle-coherence/coherence-spring-4-1-0-3-3-4-released-b34c172aec26?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/b34c172aec26</guid>
            <category><![CDATA[oracle]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Gunnar Hillert]]></dc:creator>
            <pubDate>Wed, 22 Nov 2023 03:32:59 GMT</pubDate>
            <atom:updated>2023-11-22T03:32:59.728Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BYWTXLuqQHbMx0a1IEp85g.jpeg" /><figcaption>Photo: Magic Sands Beach Park in Kailua-Kona, Hawaiʻi</figcaption></figure><p>The Oracle Coherence team is proud to announce the simultaneous release of Coherence Spring 4.1.0 and 3.3.4. This release is mostly a minor release, updating the versions of dependencies. However we do also provide several improvements in this release. Coherence Spring 4.1.0 is the first release supporting Java 21, besides supporting Java 17.</p><blockquote>Keep in mind that Coherence Spring 4.x is using Jakarta EE APIs and Java 17 is the minimum supported Java version. If you need to support Java 11 and the old Java EE APIs, please use Coherence Spring 3.3.4 instead.</blockquote><h4>Spring Session</h4><p>When using Spring for HTTP Session Management, you can now choose to not use a Coherence <a href="https://spring.coherence.community/4.1.0/refdocs/api/com/oracle/coherence/spring/session/SessionUpdateEntryProcessor.html">Entry Processor</a> to perform session updates. While this is less efficient than using the Entry Processor, where partial session updates won’t necessitate the entire session to be sent across the wire, it does eliminate the need to add your session attribute value classes to the Coherence cache server classpath, and restart Coherence clusters to deploy new versions of session attribute value classes.</p><p>To make this easily configurable, we have added a new Spring Boot property coherence.spring.session.use-entry-processor, which by default is true. If set to false, the SessionUpdateEntryProcessor is not used and the values are set by the Coherence Spring directly.</p><p>Alternatively, you can also set the useEntryProcessor property on the EnableCoherenceHttpSession annotation to false.</p><h4>Documentation</h4><p>First of all, we documented <a href="https://spring.coherence.community/4.1.0/refdocs/reference/htmlsingle/index.html#spring-session">persisting sessions without an Entry Processor</a> in the reference documentation (3.3.4 &amp; 4.1.0). Additionally, we addressed a few documentation gaps. We added a new chapter on <a href="https://spring.coherence.community/4.1.0/refdocs/reference/htmlsingle/index.html#injecting-spring-beans-into-coherence-managed-objects">Injecting Spring Beans into Coherence-Managed Objects</a> (4.1.0) and also added a chapter that provides additional documentation on how to <a href="https://spring.coherence.community/4.1.0/refdocs/reference/htmlsingle/index.html#spring-boot-coherence-cluster-setup">setup/configure Coherence Clusters</a> when using Coherence Spring (4.1.0).</p><p>Lastly, while we provide a dedicated module for Coherence Spring samples and also reference the examples throughout the reference documentation, we also have a few examples that are not hosted in the Coherence Spring GitHub repository. To have all samples referenced in one place, we added a respective appendix to the reference documentation containing a list of <a href="https://spring.coherence.community/4.1.0/refdocs/reference/html/appendix-examples.html#examples">all Spring-related Coherence examples</a>.</p><h4>Dependency Updates</h4><p>For both releases, we upgraded all (mostly minor) dependency versions wherever possible. For example Coherence Spring 3.3.4 will now support Spring Boot 2.7.17 while the 4.1.0 release supports 3.1.5. The Coherence dependency was also bumped to 23.09.1 (Coherence Spring 4.1.0) and 22.06.6 (Coherence Spring 3.3.4), respectively.</p><p>The dependency upgrade to Coherence 23.09.1 contains a breaking change for the gRPC support. The deprecated way of configuring gRPC sessions in Coherence Spring was finally removed due to Coherence 23.09.1 not supporting that particular configuration option any longer. We have therefore decided to release the 4.x line of Coherence with the bigger version bump to 4.1.0 . For more information, please see the chapter <a href="https://spring.coherence.community/4.1.0/refdocs/reference/html/spring-boot.html#spring-boot-coherence-cluster-setup-client">Access Coherence Clusters as a Client</a> in the Coherence reference guide.</p><p>As always, for a detailed list of version changes, please refer to the release notes on GitHub:</p><ul><li><a href="https://github.com/coherence-community/coherence-spring/releases/tag/v4.1.0">Coherence Spring 4.1.0 release notes</a></li><li><a href="https://github.com/coherence-community/coherence-spring/releases/tag/v3.3.4">Coherence Spring 3.3.4 release notes</a></li></ul><p>The documentation for <strong>Coherence Spring 3.3.4</strong> is available <a href="https://spring.coherence.community/3.3.4">here</a>. For version <strong>4.1.0</strong>, there reference documentation can be found <a href="https://spring.coherence.community/4.1.0/">here</a>.</p><h3>Contribute to Coherence Spring!</h3><p>We would love to hear from you! Please take Coherence Spring and <a href="https://github.com/oracle/coherence">Coherence CE</a> for a spin! If you have questions, please <a href="https://join.slack.com/t/oraclecoherence/shared_invite/enQtNzcxNTQwMTAzNjE4LTJkZWI5ZDkzNGEzOTllZDgwZDU3NGM2YjY5YWYwMzM3ODdkNTU2NmNmNDFhOWIxMDZlNjg2MzE3NmMxZWMxMWE">join our Slack channel</a> or ask questions on <a href="https://stackoverflow.com/tags/oracle-coherence">Stack Overflow</a>. If you see missing features or if you have any other suggestions for improvement please contact us, e.g. via Twitter <a href="https://twitter.com/OracleCoherence"><strong>@OracleCoherence</strong></a> or feel free to file a <a href="https://github.com/coherence-community/coherence-spring/issues">GitHub issue</a>. <strong>Contributions are always welcome</strong>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b34c172aec26" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/coherence-spring-4-1-0-3-3-4-released-b34c172aec26">Coherence Spring 4.1.0 &amp; 3.3.4 Released</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coherence CE 23.09 Is Here!]]></title>
            <link>https://medium.com/oracle-coherence/coherence-ce-23-09-is-here-1e391a1ea13c?source=rss----8c5a819cedd6---4</link>
            <guid isPermaLink="false">https://medium.com/p/1e391a1ea13c</guid>
            <category><![CDATA[coherence]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[datagrid]]></category>
            <dc:creator><![CDATA[Randy Stafford]]></dc:creator>
            <pubDate>Mon, 02 Oct 2023 16:01:27 GMT</pubDate>
            <atom:updated>2023-10-02T16:01:27.017Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yQTh_XaExt3PHmmBdRohaA.jpeg" /></figure><p>Today the Coherence team announces the availability of Coherence Community Edition (CE) release 23.09, leveraging virtual threads when running on Java 21. The release also supports Java 17 and contains many other new features and bug fixes. CE 23.09 is a non-LTS release, supported until the next Community Edition release, 24.03 in March of next year.</p><p>Elements of the release are:</p><ul><li><a href="https://github.com/oracle/coherence/releases/tag/23.09">Source code</a> on GitHub</li><li><a href="https://central.sonatype.com/search?sort=name&amp;namespace=com.oracle.coherence.ce">Artifacts</a> on Maven Central</li><li><a href="https://github.com/oracle/coherence/pkgs/container/coherence-ce">Docker images</a> on GitHub</li><li><a href="https://coherence.community/23.09/docs/#/docs/about/01_overview">Documentation</a> for 23.09</li></ul><p>CE 23.09 contains the following new features:</p><ul><li><strong>Java 21 Virtual Threads Support </strong>— <a href="https://www.oracle.com/news/announcement/ocw-oracle-releases-java-21-2023-09-19/">Java 21</a>, released ten days ago, finalized <a href="https://openjdk.org/jeps/444">virtual threads</a> as a feature of Java SE. This language feature has the potential to revolutionize Java software (like Coherence) making heavy use of multi-threading and thread pooling, from a scalability and performance perspective. Coherence CE 23.09 by default uses virtual threads when running on Java 21, in preference to platform threads in its thread pooling implementations. For more detail and discussion, refer to the <a href="https://coherence.community/23.09/docs/#/docs/core/06_virtual_threads">CE 23.09 documentation section on virtual threads</a>.</li><li><strong>Sorted Views</strong> — building on Coherence’s <a href="https://docs.oracle.com/en/middleware/standalone/coherence/14.1.1.2206/develop-applications/introduction-coherence-caches.html#GUID-0A4E65E0-1E92-4B8B-8681-AD9A8CA6D06D">client-side views</a> feature, CE 23.09 introduces the concept and implementation of Sorted Views. These are client-side view caches whose contents are sorted by either natural sort order or a custom Comparator. As views on backing distributed caches, their contents are kept in sync with the backing caches automatically. For details on how to instantiate Sorted Views, refer to the <a href="https://coherence.community/23.09/docs/#/docs/core/07_sorted_views">feature documentation</a>.</li><li><strong>Secured Production Mode</strong> — CE 23.09 allows easy configuration of a secured production mode, in which SSL/TLS communication is enabled between cluster members, and between proxy servers and their clients. The configuration can be provided either via operational overrride configuration file, or via Java system property. For further information refer to the <a href="https://coherence.community/23.09/docs/#/docs/core/08_secured_production">documentation</a>.</li></ul><p>In addition to the above major new features, CE 23.09 contains a half-dozen other more minor new features, and 51 bug fixes. For a complete list, please refer to the <a href="https://github.com/oracle/coherence/releases/tag/23.09">release notes</a>.</p><p>With support for Java 21 virtual threads, it’s a brave new world for Coherence and Coherence-based applications. We’d love to hear about your scalability and performance experiences as you take up this new release, Coherence CE 23.09.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e391a1ea13c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oracle-coherence/coherence-ce-23-09-is-here-1e391a1ea13c">Coherence CE 23.09 Is Here!</a> was originally published in <a href="https://medium.com/oracle-coherence">Oracle Coherence</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>