Memory on Netdata

Linux Cgroups V2 Memory Throttling & OOM Fix

Fri, 05 Sep 2025 00:00:00 +0000

Your critical service is lagging. Users are complaining about timeouts. You check your orchestration platform and see the dreaded OOMKilled status on a container. You dive into the node’s logs (dmesg) and confirm it: the kernel’s Out-of-Memory (OOM) killer has claimed another victim. The immediate fix is easy—restart the container, maybe give it more memory—but the real question remains unanswered: why did it happen? Was it a sudden memory leak, a traffic spike, or something more subtle?

How To Find And Fix Memory Leaks in C or C++

Tue, 10 Jun 2025 00:00:00 +0000

Your application feels sluggish. It runs perfectly after a restart, but over hours or days, it slows to a crawl before eventually crashing. If you’re working with C or C++, this behavior is a classic symptom of a memory leak—a silent bug that can drain system resources and destabilize your services. Because these languages put memory management directly in your hands, understanding how to find and fix memory leaks is a critical skill for building robust, long-running applications.

What Is A Memory Leak In Java How To Detect And Fix Them

Tue, 10 Jun 2025 00:00:00 +0000

Your Java application runs smoothly after a fresh deploy, but over hours or days, its performance steadily degrades. Response times creep up, garbage collection pauses become longer and more frequent, and then, the inevitable happens: the application crashes, logging a fatal OutOfMemoryError. This classic scenario is often the calling card of a subtle but dangerous problem—a memory leak.

Even though Java features automatic memory management via its garbage collector (GC), applications are not immune to leaks. A Java memory leak occurs when objects are no longer in use by the application, but the GC is unable to reclaim their memory because they are still being referenced. Over time, these orphaned objects accumulate, consuming the available heap space and leading to performance degradation and eventual failure. Understanding how to detect and fix these leaks is a critical skill for any Java developer.

Garbage Collection In Java What It Is and How It Works

Mon, 09 Jun 2025 00:00:00 +0000

One of the most powerful features of the Java platform is its automatic memory management. Unlike languages like C or C++, where developers must manually allocate and deallocate memory, Java handles this process for you through a process called garbage collection (GC). This frees developers to focus on application logic rather than the complexities of memory management, which is a major reason for Java’s enduring popularity.

But what exactly is garbage collection in Java, and how does it work under the hood? While it’s an automatic process, a solid understanding of the Java garbage collector is crucial for writing high-performance, stable applications and for troubleshooting memory-related issues like the dreaded OutOfMemoryError.

Nodejs Memory Leak How To Identify Debug And Avoid Them

Mon, 26 May 2025 00:00:00 +0000

In the fast-paced world of Node.js development, performance and reliability are non-negotiable. However, a silent saboteur often lurks in the shadows – the Node.js memory leak. These insidious issues can gradually degrade your application’s performance, leading to slowdowns, crashes, and frustrated users. Understanding how to effectively identify, debug, and prevent memory leaks is a critical skill for any developer, DevOps engineer, or SRE working with Node.js. This guide will walk you through the intricacies of Node.js memory management and equip you with the knowledge to tackle these challenging problems.

Key Observability Metrics | Infrastructure & APM Monitoring

Thu, 06 Jun 2024 00:00:00 +0000

What Is Observability? The Fundamentals

Noone can argue that observability is crucial for maintaining the health and performance of applications and infrastructure. Observability refers to the ability to measure and understand the state of a system based on the outputs it produces. This is extremely important for identifying, diagnosing, and resolving issues effectively and efficiently.

Observability is essential for DevOps and SRE teams as it provides a comprehensive, overall view of the infrastructure’s health, enabling proactive maintenance and quicker incident response. It involves collecting and analyzing a variety of data types, including logs, metrics, and traces, to gain insights into system behavior and it can help discover possible anomalies throughout the whole infrastructure.

Real-Time Insights for Reliable Web Hosting

Thu, 01 Feb 2024 00:00:00 +0000

Simplifying Monitoring for Enhanced Performance

Trillium was confronted with the challenge of finding an effective monitoring solution that could be easily integrated with their systems, despite the non-technical background of some team members. The company aimed to uphold its commitment to outstanding service uptime and performance—a critical aspect in the hosting industry. The search for a monitoring tool that could provide comprehensive insights into the health of their infrastructure, particularly RAM and CPU usage, and uptime tracking, led them to Netdata.

Understanding Huge Pages

Thu, 04 May 2023 00:00:00 +0000

Memory-intensive applications can benefit from improved performance by using huge pages, as they can reduce TLB pressure and memory fragmentation, and lower the memory management overhead overall. Developers should consider using HugeTLBfs in their mmap() and shmget() calls to take advantage of huge pages.

Transparent Huge Pages (THP) is a Linux kernel feature that provides some of the benefits of huge pages without requiring any development effort. However, THP can cause latency in many applications. Although kernel developers are actively working to address these issues, many system administrators prefer to disable THP altogether.

Unlock the Secrets of Kernel Memory Usage

Thu, 04 May 2023 00:00:00 +0000

The mem.kernel chart in Netdata provides insight into the memory usage of various kernel subsystems and mechanisms. By understanding these dimensions and their technical details, you can monitor your system’s kernel memory usage and identify potential issues or inefficiencies. Monitoring these dimensions can help you ensure that your system is running efficiently and provide valuable insights into the performance of your kernel and memory subsystem.

Slab

The slab allocator is a memory management mechanism introduced by Jeff Bonwick in 1994 to manage memory allocation for kernel objects. The main purpose of the slab allocator is to reduce memory fragmentation and improve the speed of memory allocation/deallocation. The slab allocator groups objects of the same size into “slabs” and caches the objects to speed up future allocations.

Swap Memory: When & How To Use It On Production VMs

Tue, 02 May 2023 00:00:00 +0000

Swap memory, also known as virtual memory, is a space on a hard disk that is used to supplement the physical memory (RAM) of a computer. The swap space is used when the system runs out of physical memory, and it moves less frequently accessed data from RAM to the hard disk, freeing up space in RAM for more frequently accessed data. But should swap memory be enabled on production systems and cloud-provided virtual machines (VMs)? Let’s explore the pros and cons.

Monitor KSM performance with Netdata

Tue, 01 Nov 2022 00:00:00 +0000

Monitoring KSM (Kernel Same-page Merging) performance at deduping memory shared across VMs.

Kernel Same-page Merging (KSM)

Linux kernels store memory in pages which are moved in and out of memory as a single block. On most Linux architectures pages are 4096 bytes. KSM (Kernel Same-page Merging) is a kernel feature that scans memory looking for pages with identical content, and then de-duplicates them. The most common use-case where such duplicate pages occur is on hosts running multiple virtual machines (VMs).

Netdata v1.31.0

Wed, 19 May 2021 00:00:00 +0000

Give a warm welcome to Netdata v1.31.0, which features:

Re-packaged and redesigned dashboard: A more informational and feature-rich “frame” for your monitoring and troubleshooting sessions.
eBPF expands into the directory cache: Monitor whether your services or applications are properly using Linux’s memory management for the best performance and minimal disk I/O.
Machine learning-powered collectors: Detect anomalies using only your own data and minimal resource utilization on your monitored nodes.
An improved Netdata learning experience: A timeline of new content, refreshed visuals, and a newly-open sourced repository.

Re-packaged and redesigned dashboard

We re-packaged and redesigned portions of the dashboard to improve the overall experience. Part of this effort is better handling of dashboard code during installation—anyone using third-party packages (such as the Netdata Homebrew formula) will start seeing new features and the new designs starting today.

For those who aren’t using third-party packages (thank you!), your installation process will still get a little bit faster.

Cassandra GC death spiral: long pauses, gossip flapping, and recovery