Learn the pros and cons of indexing log data and consider another alternative - index-free data

Log data is constantly growing and for every action that is processed, the system keeps a growing record of it. For instance, when you run a code on a system, the browser’s console creates the log - and this doesn’t stop there. Logs are important and live in countless places outside code alone.

What if you could receive real-time logs from applications that are deployed on servers? If you don’t want to miss out on the process your application goes through, knowing when your servers are down or when your application begins to malfunction becomes incredibly useful. Logs capture all these records and oftentimes detect failures before they happen.

At some point, your log volume may grow so large that you will need an efficient and fast way to organize them for easy access. What you’ll need is a way to sort through, differentiate, and identify the most important logs from the giant volume of data– and at scale. How can we prioritize the logs events? For one, logs that are alike should be kept together so that users can get them as quickly as possible.

This is where log indexing comes in. Read on to learn about the pros and cons of indexing log data, and even consider an alternative method - index-free data.



What Is Log Indexing?

Log indexing is a way to sort logs so that users can access them. It is a method of log management, where logs are arranged as keys based on some attributes. Overall, indexing engines are able to provide faster access to query logs.

Although log indexing may use chronological order, there are many other options. Some examples include indexing logs according to IDs or usernames. All you need to do is create an index with an attribute of your choice.

Pros - Log Indexing

Indexing allows efficiency and speed. In this section, we’ll look at different reasons to index your logs. We’ll also discuss the pros that indexing logs offer and why it’s an important step in managing your event data.

Optimize Query Efficiency

This is the main reason lots of people love to index logs. It’s necessary because log volume grows over time and developers should be able to find the data they need as quickly as possible.

For instance, you may want to search your logs and fish out all logs with “error” criticality. When logs grow too big, you may want to attend to them starting from “errors” down to “messages.” It takes a long time to search through several hundred log messages, therefore, indexing them before search is a great and time-saving idea. Indexed log searching reduces time when compared to logs in their crude state.

Efficient Sorting

Since logs tend to become huge over time, sorting is always a welcomed idea. What indexing does is arrange logs in a manner that will allow developers to pinpoint data faster. Sorting makes logs more readable, easy to find, and easy to access.

Avoid Duplicate Logs

In your log tables, you can prevent duplicate log files with the use of unique indexing. Unique indexes make sure that no two rows contain the same value. You can require keys to be checked for uniqueness to avoid duplicate logs. This process helps in sorting logs and ensuring querying logs are efficient.

How Log Indexing Works

Log indexing is a great option when you don’t want to search through an entire volume of logs every single time you need a particular record. This method lets you fetch the correct logs swiftly. In this section, we’ll look at how log indexing really works and how it arranges log files.

Let’s look at the table below, which consists of unordered (unindexed) logs.

Unordered Table

The logs in this example are crude, and real logs aren’t ordered as shown in the table above.

From the table above, if we try to query our table, then all entries will be queried. For instance, if we try to find all the logs with “Error” criticality, all six rows have to be searched. This action will cost time, as searching of all columns needs to be done carefully. Therefore, the best option is to index log files.

Ordered Table

Logs in the table above are ordered. As a result, if you search for logs with “Error” criticality, only the last middle rows will be searched. This will save time whenever you query your logs.

However, the log table doesn’t rearrange itself whenever there’s a change in query conditions. Instead, the log table creates a B-tree data structure. In other words, our logs will be sorted to match whatever query we make on our system. This means only the most critical information will be present in our data structure.

The data structure created will contain pointers (keys) and essential information called indexes. Once you query your logs, the system searches that crucial information and finds the result. Then, the keys will find the rest of the information from the database.

The diagram below shows how indexing really works, only the indexes are ordered and the log table remains unchanged.

Cons: Log Indexing

In cases where log indexing is used, just the task of managing and supporting the index can outweigh the effort needed to resolve problems and improve the service being monitored. Although the log management method we just discussed might seem like the best log management method, it isn’t.

We at DataSet have a number of customers who had previously and unintentionally arrived at this situation, putting them “in between a rock and a hard place”. The index-based solutions became unwieldy and resulted in problems such as:

  • Indexing log files can result in needing to store 5 to 10 times the volume of the original data
  • Transaction IDs are not keyword indexing approachable since each must be unique by definition
  • Auto-resolving queries”, the industry’s new euphemism for queries that time-out or fail
  • Slowing ingest rates
  • The need to re-start or re-index when changes are made
  • Expensive storage and compute infrastructure are required to run the indexing tool

With log indexing comes the problem of space management. This is because indexes are stored on disk space, so every new key you create gets stored in the disk. The amount of disk space, however, depends on the number of columns used for indexing. This is a big problem that comes with indexing log data.

Another problem with this log management method is the need to build and rebuild indexes. Every time log data is modified, the indexing engine has to update itself. This process involves updating all indexes. Therefore, it slows down server performance and costs developers time.

All of these reasons and more are why organizations like DataSet have come up with the alternative method of index-free data architecture.

What’s the Index-Free Method?

Having an index-less data structure can serve as a positive alternative to indexed structured data.  This log management method shifts from the traditional keyword indexing to a column-oriented log management system. In this approach, the system injects incoming data into a NoSQL columnar database to give developers a better real-time view into their data.

The advantages of this method are:

  • Less consumption of computing space
  • No rebuilding of indexes
  • Improved server performance

Columnar Database Vs. Row Data

A columnar database stores data in columns rather than the rows of a traditional row-based database. For example, in a row-based relational database, a user’s table may be stored like:



However, in a columnar database, the same data are stored like this:



DataSet uses a columnar database instead of indexes to store the data collected. Because of that, it’s able to provide fast data ingestion and parsing. This makes your data available more quickly for things like searches and alerts. Benefits of columnar databases include:

  • Column stores can be much more efficiently compressed than row stores because contiguous data in a column is all of the same type.
  • Adding new columns to a columnar database is very quick and easy due to the way data is stored.
  • Processing strength is strong in performing aggregation queries and collecting all the data from multiple columns very quickly and efficiently.

Overall, the impact of index-free data leads to higher uptime, allowing the system to ingest logs and serve queries faster and at scale. They’re well suited to analytical processing, effectively compressed, and flexibly scaled horizontally.

Try Logging with Index-Free Data 

With DataSet, you don’t need to deal with log indexing because of its unique index-free architecture. With a columnar database instead of log indexing, event data can quickly serve users that are querying their logs–whether for live streaming dashboards or for ad-hoc historic queries.

Now that you know the pros and cons of log indexing, it’s up to you to see if index-free data is the better choice in the long term when dealing with growing log volumes and total cost of ownership.

You may want to try DataSet and see for yourself - free of charge for the first 30 days.