Elasticsearch Nodejs Integration for Optimal Search Performance

In today’s data-driven world, synergy between Elasticsearch and Nodejs and amplify your website’s search capabilities. Whether you’re managing a large e-commerce platform, building a content-rich website, or analyzing complex datasets, having a robust search solution is paramount. This is where the dynamic duo of Elasticsearch and Node.js comes into play.

Elasticsearch, a powerful search engine built on top of Apache Lucene, offers unparalleled speed, scalability, and flexibility for handling massive amounts of data. Its intuitive REST API makes it easy to integrate with various programming languages, including the ever-popular Node.js. Node.js, known for its asynchronous and event-driven nature, shines in building real-time applications that require constant interaction with a search engine like Elasticsearch.

This blog post serves as your comprehensive guide to harnessing the combined power of Elasticsearch and Node.js. We’ll delve into the fundamentals of both technologies, explore the setup process, and guide you through building a Node.js client to interact with Elasticsearch. We’ll then showcase how to index your data for efficient search and craft powerful queries to retrieve the exact information you need, all within the comfort of Node.js.

By the end of this journey, you’ll be equipped to implement a robust search functionality in your Node.js applications, empowering users to effortlessly find what they’re looking for within your data landscape. So, buckle up and get ready to unlock the true potential of search with Elasticsearch and Node.js!

1. Diving into Elasticsearch and Node.js for Powerful Search

In the ever-expanding digital realm, information overload is a real challenge. Imagine a vast library with countless books piled high, each containing valuable knowledge. Without a proper search system, navigating this information ocean can be frustrating and time-consuming. This is where powerful search technologies like Elasticsearch come to the rescue.

Elasticsearch, built on the rock-solid foundation of Apache Lucene, is a game-changer in the search engine world. Here’s what makes it stand out:

Blazing-Fast Speed: Elasticsearch boasts lightning-fast search capabilities. It excels at processing massive datasets in milliseconds, returning relevant results almost instantly. This is crucial for applications where users expect immediate search responses.
Scalability for the Future: As your data volume grows, so should your search engine. Elasticsearch is built for scalability, allowing you to effortlessly add more servers to handle increasing data demands. This ensures your search functionality remains efficient even as your data landscape expands.
Flexibility at its Finest: Elasticsearch isn’t a one-size-fits-all solution. It offers a high degree of flexibility, allowing you to customize its behavior to perfectly match your specific search needs. You can define how documents are indexed, tailor search queries, and configure various settings to optimize search results for your unique use case.
Power of Relevance: Elasticsearch goes beyond just returning any document containing your search terms. It employs sophisticated ranking algorithms to prioritize the most relevant results based on factors like keyword placement, document context, and even user search history (if applicable). This ensures users find the most pertinent information first, saving them valuable time and frustration.

Now, let’s shift gears and talk about Node.js. This JavaScript runtime environment has taken the development world by storm. Here’s why it’s a perfect partner for Elasticsearch:

Asynchronous Magic: Node.js is all about asynchronous programming. This means it can handle multiple tasks simultaneously without getting bogged down. This is ideal for search applications where you might be dealing with numerous search requests at once.
Event-Driven Architecture: Node.js thrives on an event-driven architecture. This means it can react to events (like a user submitting a search query) efficiently, making it well-suited for building real-time search experiences.
JavaScript Familiarity: JavaScript is one of the most popular programming languages globally. For developers already comfortable with JavaScript, Node.js provides a familiar and efficient environment to build applications.
Rich Ecosystem: The Node.js ecosystem is vast and ever-growing. It offers a plethora of libraries and frameworks that simplify various development tasks, including building a Node.js client for interacting with Elasticsearch.

Now that we understand the strengths of both Elasticsearch and Node.js, let’s explore how they work together to create a powerful search solution. Here’s the magic behind the scenes:

Data Indexing: The first step involves indexing your data in Elasticsearch. This process involves preparing your data and feeding it into Elasticsearch in a structured format. Elasticsearch then analyzes and optimizes the data for efficient searching.
Node.js Client: This is your bridge between the Node.js application and Elasticsearch. You’ll build a Node.js client that utilizes the Elasticsearch REST API to communicate with the search engine. This client sends search queries, receives results, and manages various interactions with Elasticsearch.
Search Queries: Once the data is indexed and the client is set up, users can start submitting search queries through your Node.js application. These queries are sent to Elasticsearch via the Node.js client, instructing it to find relevant documents based on specific criteria.
Ranked Results: Elasticsearch processes the search query, retrieves the most relevant documents from its index, and ranks them based on its sophisticated algorithms. The ranked results are then sent back to your Node.js client, which displays them in a user-friendly format within your application.

This seamless collaboration between Elasticsearch and Node.js empowers you to build applications with lightning-fast, highly relevant, and scalable search functionalities.

In the next chapter, we’ll delve into the practical side of things. We’ll guide you through setting up your Elasticsearch and Node.js environment, paving the way for building your powerful search solution.

2. Gearing Up: Setting Up Elasticsearch and Node.js Environment

Now that we’re excited about the potential of Elasticsearch and Node.js for building powerful search functionalities, let’s roll up our sleeves and get down to business! This chapter will equip you with the knowledge to set up your development environment, preparing you to build your Node.js client for interacting with Elasticsearch.

There are two main approaches to setting up Elasticsearch:

1. Local Installation:

This approach involves installing Elasticsearch directly on your development machine. This is a great option for getting started and experimenting with the technology. Here’s what you’ll need:

Java Runtime Environment (JRE): Elasticsearch is built on Java, so you’ll need a recent version of JRE installed on your machine. You can download it from the official Java website (https://www.oracle.com/java/technologies/downloads/).
Downloading Elasticsearch: Head over to the Elasticsearch download page (https://www.elastic.co/downloads/elasticsearch) and grab the latest stable version that’s compatible with your operating system. There are options for Windows, macOS, and Linux distributions.
Starting Elasticsearch: Once downloaded, extract the archive and navigate to the extracted directory in your terminal. Locate a script named “elasticsearch” (or “elasticsearch.bat” on Windows) and run it. This will start the Elasticsearch server on your local machine, typically on port 9200 by default.

2. Running Elasticsearch in Docker:

Docker provides a convenient way to run Elasticsearch in a containerized environment. This approach offers benefits like isolation, portability, and easy deployment. Here’s what you’ll need:

Docker Desktop: Download and install Docker Desktop for your operating system from https://www.docker.com/products/docker-desktop/. This will provide the necessary tools to manage Docker containers.
Docker Hub Image: Docker Hub, a public registry for container images, provides a pre-built Elasticsearch image. You can pull this image using the following command in your terminal:

docker pull elasticsearch:latest

Running the Container: Once the image is downloaded, you can start an Elasticsearch container using the following command:

docker run -d -p 9200:9200 elasticsearch:latest

This command runs the Elasticsearch image in detached mode (-d) and maps the container’s port 9200 to your host machine’s port 9200 (-p 9200:9200).

Verifying Elasticsearch:

To confirm that Elasticsearch is running successfully, you can use a web browser and navigate to http://localhost:9200 (or the appropriate URL if you used a different port mapping). This should display the Elasticsearch information panel, indicating that the server is up and running.

Setting Up Node.js:

Now that Elasticsearch is up and running, let’s get Node.js ready. Here’s what you’ll need:

Node.js and npm: Download and install the latest version of Node.js from the official website (https://nodejs.org/en). Node.js comes bundled with npm (Node Package Manager), which we’ll use to install necessary libraries.

Creating a Node.js Project:

Open your terminal and navigate to your desired project directory.
Initialize a new Node.js project by running npm init -y in your terminal. This will create a package.json file that stores project information and dependencies.

Installing the Elasticsearch Client Library:

Now, it’s time to connect your Node.js application with Elasticsearch. We’ll use the official Elasticsearch JavaScript Client library, which provides a user-friendly way to interact with the search engine’s REST API. Install it using npm with the following command:

npm install @elastic/elasticsearch

This command will download and install the @elastic/elasticsearch library into your project’s node_modules directory.

Testing the Connection:

Let’s create a simple Node.js script to test the connection with Elasticsearch. Create a file named test.js in your project directory and paste the following code:

const { Client } = require('@elastic/elasticsearch');

const client = new Client({ node: 'http://localhost:9200' });

async function ping() {
  try {
    const { body } = await client.ping();
    console.log("Elasticsearch is up and running: ", body);
  } catch (error) {
    console.error("Failed to connect to Elasticsearch:", error);
  }
}

ping();

(async () => {
  try {
    // Create a sample index (replace with your desired index name)
    const createIndexResponse = await client.indices.create({
      index: 'my_index',
    });
    console.log("Created index:", createIndexResponse);
  } catch (error) {
    console.error("Failed to create index:", error);
  }
})();

Explanation of the Continued Code:

Index Creation (Optional): The previous code snippet demonstrated pinging Elasticsearch to verify connectivity. Now, we’ve added an additional asynchronous function that attempts to create a sample index named “my_index” using the client.indices.create API.
Replacing Index Name: Remember to replace “my_index” with the actual name you want to use for your index in your Node.js application. This index will store your data for searching later.
Error Handling: The code includes error handling using a try...catch block. If the index creation fails, the error message will be logged to the console for debugging purposes.

Running the Script:

Save the test.js file.
In your terminal, navigate to the directory containing test.js.
Run the script using node test.js.

If everything is set up correctly, you should see output in your terminal indicating successful connection to Elasticsearch and (optionally) the creation of your sample index.

Next Steps:

In the next chapter, we’ll delve deeper into building your Node.js client for interacting with Elasticsearch. We’ll explore how to connect to specific indices, send search queries, and retrieve relevant results, empowering you to unlock the true potential of search in your Node.js applications.

3. Connecting the Dots: Building Your Node.js Client for Elasticsearch

Now that you have a running Elasticsearch instance and a basic understanding of its interaction with Node.js, it’s time to build the bridge between them! This chapter will guide you through creating a robust Node.js client that seamlessly interacts with Elasticsearch using its REST API.

Understanding the REST API:

Elasticsearch exposes a powerful REST API that allows you to manage data and perform searches using HTTP requests. Your Node.js client will utilize this API to communicate with the search engine. Here’s a breakdown of some key API actions:

GET: This method retrieves information from Elasticsearch. For instance, you might use GET requests to check the cluster health, retrieve information about specific indices, or fetch existing documents.
PUT: This method creates or updates data in Elasticsearch. You’ll use PUT to create new indices, define index mappings (specifying how data is stored and analyzed), and index individual documents.
POST: This method is often used for bulk operations like indexing multiple documents at once or performing complex search queries.
DELETE: This method removes data from Elasticsearch. You might use DELETE to remove an entire index or specific documents within an index.

Building the Client:

As mentioned earlier, we’ll leverage the official Elasticsearch JavaScript Client library (@elastic/elasticsearch) for building our Node.js client. Here’s how we’ll structure it:

Client Initialization: At the start of your Node.js application, you’ll create an instance of the Client class from the library. This instance will hold the connection configuration, allowing you to communicate with your Elasticsearch server.

const { Client } = require('@elastic/elasticsearch');

const client = new Client({ node: 'http://localhost:9200' });

In this example, the client is configured to connect to the Elasticsearch server running on your local machine at port 9200. Remember to replace this with the actual URL and port if your Elasticsearch setup is different.

API Calls: The Client object provides various methods for interacting with the Elasticsearch REST API. These methods typically map to the HTTP methods mentioned earlier (GET, PUT, POST, DELETE).

Here are some commonly used methods:

ping(): This method checks if the Elasticsearch server is up and running.
indices.create({ index: ‘my_index’ }): This method creates a new index named “my_index” in Elasticsearch.
index({ index: ‘my_index’, id: 1, body: { title: ‘My Document Title’ } }): This method indexes a new document with the ID 1 and a specific body containing a title field in the “my_index” index.
search({ index: ‘my_index’, body: { query: { match: { title: ‘search term’ } } } }): This method performs a search query for documents containing the term “search term” in the title field within the “my_index” index.

Error Handling:

As with any communication channel, errors can occur while interacting with Elasticsearch. It’s crucial to implement proper error handling in your Node.js client to gracefully handle these situations. Here’s how you can achieve this:

Try…Catch Blocks: Most API methods in the Elasticsearch client library return promises. You can utilize try...catch blocks around these promises to capture any potential errors during the operation.
Error Logging: Within the catch block, log the error details to your application log or console for debugging purposes. This will help you identify and troubleshoot any issues that might arise while interacting with Elasticsearch.

Putting it All Together:

Let’s create a simple Node.js script that demonstrates connecting to Elasticsearch, creating an index, indexing a document, and performing a search:

const { Client } = require('@elastic/elasticsearch');

const client = new Client({ node: 'http://localhost:9200' });

async function main() {
  try {
    // Create an index (replace with your desired name)
    const createIndexResponse = await client.indices.create({
      index: 'my_articles',
    });
    console.log("Created index:", createIndexResponse);

    // Define a document to index
    const document = {
      title: 'A Comprehensive Guide to Node.js',
      content: 'This article explores the key concepts of Node.js...',
    };

    // Index the document
    const indexResponse = await client.index({
      index: 'my_articles',
      id: 1,
      body: document,
    });
    console.log("Indexed document:", indexResponse);

    // Search for documents containing "Node.js" in the title
    const searchResponse = await client.search({
      index: 'my_articles',
      body: {
        query: {
          match: {
            title: 'Node.js',
          },
        },
      },
    });
    console.log("Search results:", searchResponse.hits.hits);
  } catch (error) {
    console.error("Error:", error);
  }
}

main();

Explanation of the Continued Code:

Search Functionality: We’ve added a new section to perform a search query. The client.search method is used, specifying the target index (“my_articles”) and the search query itself.
Match Query: The search query uses a match query that searches for documents where the title field contains the term “Node.js”. This is a basic example, and we’ll explore more advanced search capabilities in future chapters.
Search Results: The search response object contains information about the matching documents, including their relevance scores (how well they match the query). We’re logging only the hits.hits portion of the response, which is an array containing details about the retrieved documents.

Running the Script:

Save the script (e.g., elasticsearch_client.js) and run it from your terminal using node elasticsearch_client.js. If everything is set up correctly, you should see output indicating the creation of the index, document indexing, and the search results containing the document with “Node.js” in the title.

Beyond the Basics:

This script demonstrates the fundamental building blocks for interacting with Elasticsearch from your Node.js application. As you progress, you’ll explore more advanced functionalities like:

Complex Search Queries: Elasticsearch offers a wide range of query types for fine-tuning your search results. You can use filters, aggregations, and faceting to achieve sophisticated search experiences.
Data Analysis: Elasticsearch goes beyond just search. You can leverage its capabilities for data analysis tasks like identifying trends and patterns within your indexed data.
Bulk Operations: For large datasets, indexing or deleting documents one by one can be inefficient. The Elasticsearch client library provides methods for performing bulk operations to optimize performance.

Conclusion:

This chapter equipped you with the knowledge to build a basic Node.js client for interacting with Elasticsearch. With this foundation, you’re well on your way to unlocking the power of search in your Node.js applications. The next chapter will delve into the exciting realm of indexing your data for efficient searching in Elasticsearch.

4. Indexing Your Data: Making Information Searchable with Elasticsearch

In the previous chapter, we established a solid connection between your Node.js application and Elasticsearch. Now, it’s time to populate Elasticsearch with your valuable data! This chapter will guide you through understanding the concept of indexing in Elasticsearch and how to effectively prepare your data for efficient searching.

Understanding Indexing:

Indexing is the process of preparing your data and storing it in a structured format within Elasticsearch. When you index a piece of data (like a document, product information, or user profile), Elasticsearch analyzes it, extracts relevant keywords, and builds an inverted index – a sophisticated data structure that allows for lightning-fast searches.

Data Preparation:

Before feeding your data to Elasticsearch, some preparation is necessary to ensure optimal search performance and relevance. Here are some key aspects to consider:

Data Structure: Elasticsearch thrives on well-structured data. Organize your data into documents, with each document representing a single entity or record. Within each document, define clear fields to categorize different pieces of information (e.g., title, content, author for an article).
Data Cleaning: Real-world data often contains inconsistencies or errors (missing values, typos, etc.). Clean your data to remove these imperfections and ensure the search results are based on accurate information. Techniques like normalization, deduplication, and formatting can be applied during data preparation.
Data Transformation: Sometimes, your data might require transformation to be more suitable for searching. This could involve splitting long text into smaller chunks, converting dates to a consistent format, or removing special characters that might hinder search accuracy.

Defining Mappings:

While indexing data, you have the opportunity to define mappings in Elasticsearch. Mappings essentially tell Elasticsearch how to interpret and analyze your data for searching purposes. Here’s what you can specify within mappings:

Data Types: Define the data type for each field in your documents. Common data types include strings, integers, dates, booleans, and more.
Analyzers: Analyzers are powerful tools that break down text into meaningful units for searching. Elasticsearch provides various built-in analyzers like standard analyzers (splitting text into words) or keyword analyzers (treating the entire field as a single token). You can even create custom analyzers for specific needs.
Tokenization: Tokenization involves breaking down text into smaller units called tokens. Analyzers define the tokenization rules. You can control how text is split (e.g., at word boundaries) and whether special characters are removed or kept during tokenization.
Stemming and Lemmatization: These techniques aim to reduce words to their root form (e.g., “running” to “run”). This can improve search relevance by matching searches for plurals or different variations of the same word.

Effective Indexing Strategies:

Here are some best practices to ensure your Elasticsearch indexing process is efficient and leads to optimal search results:

Bulk Indexing: For large datasets, consider using bulk indexing operations. Instead of indexing documents one by one, you can batch them together for improved performance. The Elasticsearch client library provides methods for bulk indexing to optimize data ingestion.
Partial Updates: Instead of re-indexing entire documents for minor changes, leverage partial updates. This allows you to modify specific fields within existing documents without impacting search performance or re-indexing everything.
Relevance Tuning: Elasticsearch provides various techniques for tuning the relevance of search results. You can define boost factors for specific fields to prioritize them in searches or leverage weighting schemes based on document freshness or other factors.

Example: Indexing Articles in Node.js

Let’s revisit the example from the previous chapter where we indexed a document about Node.js. Here’s how we can improve the document structure and indexing process:

const document = {
  title: 'A Comprehensive Guide to Node.js',
  content: 'This article explores the key concepts of Node.js, a popular JavaScript runtime environment...',
  published_date: new Date().toISOString(), // Store date in a consistent format
  author: {
    name: 'John Doe',
  },
  // ... other relevant fields for your articles
};

async function indexArticle(client, article) {
  try {
    const response = await client.index({
      index: 'my_articles',
      id: article.id, // Assuming you have an ID for each article
      body: article,
    });
    console.log("Indexed article:", response);
  } catch (error) {
    console.error("Error indexing article:", error);
  }
}

// Assuming you have an array of articles to index
const articles = [
  // ... articles to be indexed
];

(async () => {
  try {
    for (const article of articles) {
      await indexArticle(client, article);
    }
  } catch (error) {
    console.error("Error indexing articles:", error);
  }
})();

Explanation of the Continued Code:

Looping Through Articles: We’ve replaced the single article example with an assumption that you have an array of articles to be indexed. The code iterates through this array, calling the indexArticle function for each article.
Bulk Indexing Potential: While this example iterates and indexes articles one by one, you can explore bulk indexing functionalities provided by the Elasticsearch client library to improve performance when dealing with large datasets.

Defining Mappings in Node.js:

While the previous code demonstrates basic indexing, you can further enhance it by defining mappings in your Node.js application. Here’s an example using the @elastic/elasticsearch client:

async function createMappings(client) {
  try {
    const response = await client.indices.create({
      index: 'my_articles',
      body: {
        mappings: {
          properties: {
            title: { type: 'text', analyzer: 'standard' },
            content: { type: 'text', analyzer: 'standard' },
            published_date: { type: 'date' },
            author: {
              type: 'nested',
              properties: {
                name: { type: 'keyword' },
              },
            },
            // ... define mappings for other fields
          },
        },
      },
    });
    console.log("Created mappings:", response);
  } catch (error) {
    console.error("Error creating mappings:", error);
  }
}

Explanation of the Mappings Code:

createMappings Function: This function defines the mappings for the “my_articles” index using the client.indices.create method.
Mapping Properties: The mappings object specifies the properties for each field in your documents. We’ve defined mappings for title, content, published_date, and a nested author object.
Data Types and Analyzers: We’ve defined data types (e.g., text for title and content) and assigned the standard analyzer for text fields. This instructs Elasticsearch to break down text into words for searching.
Nested Object: The author field is defined as a nested object with its own property (name) mapped as a keyword (treated as a single unit during search).

Conclusion:

By understanding indexing principles, data preparation techniques, and effective mapping strategies, you can ensure your data in Elasticsearch is well-structured and optimized for efficient searching. The next chapter will delve into the exciting world of crafting powerful search queries in Node.js to retrieve the exact information you need from your indexed data.

5. Unleashing Search Power: Crafting Effective Queries in Node.js

Now that you’ve successfully indexed your data in Elasticsearch and established a robust connection from your Node.js application, it’s time to unleash the true power of search! This chapter will equip you with the knowledge to craft effective search queries in Node.js, enabling you to retrieve the most relevant information from your indexed data.

Understanding Search Queries:

Search queries are the instructions you provide to Elasticsearch to find specific documents or information within your index. Elasticsearch offers a powerful query DSL (Domain Specific Language) that allows you to express complex search criteria.

Basic Search Queries:

Let’s explore some fundamental search queries you can use in your Node.js application:

Match Query: This is the most basic query type. It searches for documents where a specific field contains a particular term. For example, a query like:

{
  query: {
    match: {
      title: 'Node.js',
    },
  },
}

would search for documents in your index where the title field contains the term “Node.js”.

Multi-Match Query: This query allows you to search across multiple fields simultaneously. You can specify weights for each field to prioritize certain fields in the search results. Here’s an example:

{
  query: {
    multi_match: {
      query: 'JavaScript framework',
      fields: ['title', 'content'], // Search in both title and content fields
    },
  },
}

Term Query: This query searches for documents where a specific field has an exact value. It’s useful for searching for terms that shouldn’t be broken down (e.g., product IDs, unique identifiers).

Advanced Search Options:

Elasticsearch offers a vast array of advanced search options to refine your search results and achieve pinpoint accuracy:

Boolean Queries: Combine multiple queries using operators like AND, OR, and NOT to create more complex search criteria.
Wildcard Queries: Use wildcards like asterisks () to match variations of a term. For instance, “computr” would match documents containing “computer”, “computers”, or “computing”.
Fuzzy Queries: Find documents with terms that have slight misspellings or typos using fuzzy queries. This can be helpful for handling user-generated search queries with potential errors.
Filters: Filter down your search results based on additional criteria without affecting the scoring of documents. For example, you might filter to only show articles published after a specific date.

Sorting Search Results:

By default, Elasticsearch sorts search results based on a relevance score. This score reflects how well each document matches the search query. However, you can customize the sorting behavior using the sort parameter in your query. Here’s an example sorting by published date in descending order:

{
  sort: [
    { published_date: { order: 'desc' } },
  ],
}

Aggregations:

Aggregations allow you to group and analyze your search results to gain valuable insights from your data. You can perform various aggregations like counting documents that match specific criteria, calculating average values for numerical fields, or finding the most frequent terms within a particular field.

Search Queries in Node.js:

Let’s revisit our Node.js client example and see how to incorporate search queries:

async function searchArticles(client, query) {
  try {
    const response = await client.search({
      index: 'my_articles',
      body: query,
    });
    console.log("Search results:", response.hits.hits);
  } catch (error) {
    console.error("Error searching articles:", error);
  }
}

// Example query with aggregations: Find most frequent categories in articles
const searchQuery = {
  size: 0, // Set size to 0 to retrieve only aggregations, not documents
  aggs: {
    categories: {
      terms: { field: 'category' }, // Group by the "category" field
    },
  },
};

searchArticles(client, searchQuery);

Explanation of the Continued Code:

Aggregation for Categories: The searchQuery object now includes an aggs property for defining aggregations. In this example, we’re using a terms aggregation on the category field. This will group articles by their category and return the most frequent categories.
size: 0 Optimization: Since we’re only interested in aggregations and not retrieving actual documents, we’ve set the size parameter to 0. This optimizes the search by instructing Elasticsearch not to return any document hits in the response.

Error Handling and Logging:

As you build more complex search functionalities in your Node.js application, robust error handling and logging become crucial. Remember to incorporate proper error handling mechanisms within your try...catch blocks to capture any issues during search execution. Additionally, consider logging search queries and results for debugging and monitoring purposes.

Conclusion:

This chapter equipped you with the foundation for crafting powerful search queries in Node.js. With the knowledge of basic and advanced search options, aggregations, and the ability to customize sorting and filtering, you can unleash the true potential of Elasticsearch and empower your applications with sophisticated search capabilities. The next chapter will delve into practical considerations and best practices for managing your Elasticsearch deployment and ensuring optimal performance over time.