How does DalmatinerDB handle data loss in crashes?

DalmatinerDB uses best-effort writes without forced syncs, so unwritten data can be lost during crashes; it relies on ZFS's ZIL for logging if enabled, but aggregates are prioritized over individual points.

DalmatinerDB vs InfluxDB for monitoring metrics?

DalmatinerDB focuses on high-throughput, low-overhead ingestion with explicit tradeoffs like best-effort writes, while InfluxDB offers more features, SQL-like queries, and a larger ecosystem but with higher complexity.

How to install and configure DalmatinerDB with ZFS?

Set up a ZFS filesystem on your server, create a dataset for storage, and point DalmatinerDB to that path; detailed steps are in the official documentation, but it requires ZFS familiarity.

Is DalmatinerDB good for storing IoT sensor data?

Yes, it's well-suited for IoT metrics due to efficient write handling and time-series focus, but ensure occasional data loss is acceptable, as best-effort writes might drop points during network issues.

What are the main tradeoffs compared to other metric databases?

Key tradeoffs include best-effort writes risking data loss, dependency on ZFS for optimal performance, and a simplified architecture that may lack advanced querying or tooling found in alternatives.

How do you query and retrieve metrics from DalmatinerDB?

DalmatinerDB provides efficient querying through its own API or tools designed for time-series data; check the documentation for specific endpoints and examples, but it's tailored for metric aggregates.

Open-Awesome

Dalmatiner DB

MITErlang

A fast, low-overhead metric database written in pure Erlang, optimized for time-series data storage and querying.

Visit Website GitHub

692 stars40 forks0 contributors

What is Dalmatiner DB?

DalmatinerDB is a metric database written in pure Erlang, specifically designed for storing and querying time-series data (timestamp and value pairs). It optimizes for speed and low overhead by leveraging filesystem capabilities like ZFS and using a flat binary storage format, making tradeoffs such as best-effort writes to prioritize high-volume ingestion.

Target Audience

Developers and operations teams needing a performant, self-hosted metric database for monitoring, telemetry, or IoT applications, especially those already using Erlang ecosystems or ZFS filesystems.

Value Proposition

It offers a simplified, high-performance alternative to general-purpose time-series databases by explicitly embracing tradeoffs like filesystem delegation and best-effort writes, resulting in reduced complexity and efficient resource usage for metric-specific workloads.

Overview

See gitlab: https://gitlab.com/Project-FiFo/DalmatinerDB/dalmatinerdb

Use Cases

Best For

High-frequency metric ingestion from distributed systems
Self-hosted monitoring and telemetry backends
Time-series data storage with ZFS filesystems
Erlang-based infrastructure needing native metric storage
Environments where aggregate metric trends matter more than individual data points
Scenarios prioritizing write throughput over absolute data durability

Not Ideal For

Applications where every single data point must be guaranteed durable, such as financial transaction logging or audit trails.
Teams operating in environments without ZFS filesystems or unwilling to manage ZFS-specific configurations.
Projects requiring extensive third-party integrations, dashboards, or SQL-like query capabilities beyond basic metric storage.
Use cases needing real-time, low-latency analytics with complex joins or transformations on time-series data.

Pros & Cons

Pros

High Write Throughput

Prioritizes overall writes with best-effort semantics, enabling high-volume metric ingestion without per-write sync overhead, as explicitly traded off in the README for performance.

Filesystem Delegation

Offloads tasks like checksums, compression, and caching to the filesystem, especially ZFS, simplifying the codebase and leveraging proven, performant systems instead of reimplementing them.

Simple Storage Model

Uses flat binary files where reads and writes are calculated via filename and offset with simple math, eliminating complex data structure traversal for fast access.

Erlang Concurrency Benefits

Built in pure Erlang, it leverages native concurrency and fault-tolerance, making it robust for handling distributed metric workloads efficiently.

Cons

Risk of Data Loss

Employs best-effort writes with no forced sync or write logs, meaning network failures or server crashes can lead to lost data points, as acknowledged in the README's tradeoffs section.

ZFS Dependency for Optimal Use

Relies on ZFS for features like intent logging and compression to achieve full performance, limiting flexibility in environments without ZFS or requiring additional setup.

Limited Ecosystem and Tooling

As a specialized Erlang-based database, it may lack the broad third-party integrations, visualization tools, and community support compared to more popular time-series solutions.

Frequently Asked Questions

Related Projects

TiDB

TiDB is built for agentic workloads that grow unpredictably, with ACID guarantees and native support for transactions, analytics, and vector search. No data silos. No noisy neighbors. No infrastructure ceiling.

Scalable datastore for metrics, events, and real-time analytics

Stars31,600

Forks3,713

Last commit22 hours ago

RQLite

The lightweight, fault-tolerant database built on SQLite. Designed to keep your data highly available with minimal effort.

Stars17,614

Forks792

Last commit3 days ago

ScyllaDB

NoSQL data store using the Seastar framework, compatible with Apache Cassandra and Amazon DynamoDB

Stars15,630

Forks1,506