Free audit

View Audit Scope
DragonflyRemote DBA, support, and scoped projects

Dragonfly database services for production teams.

JusDB provides Dragonfly database services for scoped projects, ongoing remote DBA coverage, production support, moves from Redis and Valkey, and high availability. We work on your own servers and cloud VMs, on Kubernetes with the Dragonfly Operator, and on Dragonfly Cloud. 24x7 on-call is available under your service agreement.

Or request a free audit of one database instance. Already in an incident? See how incidents are handled.

  • NDA before access
  • Read-only by default
  • Changes measured against your baseline

Dragonfly version status

Pick the version you run

Dragonfly 2.0

Newest major

Released on 16 September 2026, with patch 2.0.2 on 7 October 2026. It caps the replication backlog by age and size.

Earlier releases cannot read Valkey 9 snapshot files, so loading one needs Dragonfly 2.0 or later.

Plan the upgrade to 2.0

Version status from the Dragonfly releases, the Dragonfly Operator releases, and the Dragonfly replication documentation, checked 28 October 2026.

Platforms
Your own servers and cloud VMs, Kubernetes with the Dragonfly Operator, and Dragonfly Cloud
High availability
Replicas promoted by Redis Sentinel, the Dragonfly Operator, or Dragonfly Cloud
Incidents
Initial-response targets are set in your service agreement. See the targets

Symptoms

Eight Dragonfly problems we are asked to fix

Each one has a cause we can measure. The scoping call starts from the symptom you see, the Dragonfly version, and where it runs.

  1. A Lua script fails right after the move from Redis because Dragonfly rejects any key the script did not declare in KEYS, unless the allow-undeclared-keys flag is set.

  2. Every command stalls while one Lua script runs because a script allowed to touch undeclared keys makes Dragonfly stop all other operations until it finishes.

  3. One core is saturated while the others sit idle because each key belongs to one shard, owned by a single thread, so the work on a hot key stays on one core.

  4. Writes fail with out-of-memory errors at the memory limit because Dragonfly evicts keys only in cache mode (--cache_mode), which is off by default.

  5. Dragonfly exits at start under a small memory limit because it needs at least 256 MB of maxmemory per thread, and by default it starts one thread per CPU core.

  6. Replicas run full syncs after short network drops because from Dragonfly 2.0 the replication backlog keeps about 5 seconds of writes by default (--shard_repl_backlog_time_ms).

  7. Replicating from a Redis 7 primary is unsupported because Dragonfly supports replication only from Redis OSS 6.2 and earlier, so the data moves another way, such as an RDB snapshot.

  8. Redis Functions and modules do not carry over because Dragonfly does not support FCALL, FUNCTION, or MODULE LOAD, although it implements JSON, search, and Bloom filter commands itself.

If one of these is costing your team time, a scoping call is the place to start.

Book a 30-min scoping call (opens Google Calendar in a new tab)

Durability

How a crash can lose confirmed Dragonfly writes

Dragonfly has no append-only file (AOF), so a restarted node comes back with only its last snapshot. Replicas copy writes asynchronously, so a promoted replica can also miss the last writes the primary confirmed.

One primary, one replica, three outcomes

Choose a state to see which writes survive.

Clients and failover

Clients send writes to the primary and can read from the replica.

Writes on the primary
  • Primary

    Confirms each write without waiting for the replica

    Healthy

  • Replica

    Applies the primary's stream of changes a moment later

    Slightly behind

  • Snapshot

    The last one saved to disk, loaded if the node restarts

    On disk

For a moment after each write, the newest data exists only in the primary's memory.

We decide per workload how much loss is acceptable, because a session cache can restart empty and a job queue cannot. We set --snapshot_cron, --dir, and --dbfilename to match, and copy snapshots off the host. Where a write must reach a replica first, we use WAIT, available from Dragonfly 1.40.

Dragonfly does not fail over by itself, so we use three or more Redis Sentinels, the Dragonfly Operator, or the failover built into Dragonfly Cloud. We alert on replica lag from INFO REPLICATION and rehearse a failover and a snapshot restore on a copy. For planned switchovers we use REPLTAKEOVER, which waits until the replica has applied every write.

What we cover

Full-spectrum Dragonfly engineering

From one hot key to a move off Redis: INFO, SLOWLOG, Prometheus metrics, and the command compatibility list drive every change.

  • Performance engineering

    We find the limit first, whether a hot key, a slow script, or memory, and measure each change against your baseline.

    • Hot keys found and spread across several keys
    • SLOWLOG and INFO read on the real workload
    • Lua scripts checked for undeclared keys
    Database performance tuning
  • Vertical scaling

    We size one node's threads and memory before you move Redis Cluster shards onto it.

    • --proactor_threads matched to the cores you run
    • --maxmemory set below the host or container limit
    • Emulated cluster mode for Redis Cluster clients
    Dragonfly cores and memory review
  • High availability

    Failover planned around the data loss and downtime you can accept (RPO and RTO), then rehearsed.

    • Three or more Redis Sentinels, or the Dragonfly Operator
    • WAIT for writes that must reach a replica first
    • Planned switchovers with REPLTAKEOVER
    Database high availability
  • Redis and Memcached compatibility

    We check the commands, scripts, and client libraries your workload uses before any cutover, and plan a rollback.

    • Unsupported commands such as FCALL and SWAPDB found early
    • Snapshot moves, or replication from Redis OSS 6.2 and earlier
    • Memcached clients served on --memcached_port
    Database migration
  • Cloud and Kubernetes

    Your own servers, Kubernetes with the Dragonfly Operator, or Dragonfly Cloud, chosen by who should run failover and snapshots.

    • Operator failover and rolling updates
    • Snapshots to persistent volumes or Amazon S3
    • Dragonfly Swarm when data outgrows one node
    Dragonfly on Kubernetes
  • Managed DBA

    Ongoing monitoring, maintenance, and incident response for Dragonfly under an agreed scope.

    • Prometheus metrics in your dashboards
    • Alerts on memory headroom, replica lag, and snapshot age
    • Snapshot restores tested on a copy
    Remote DBA

Incident support

A critical (P1) page, answered within your agreement's target

JusDB keeps your recovery procedures (runbooks) written down, so an incident starts from a known plan instead of a blank page.

Initial-response targets

  • 2 to 4 hours

    Business hours

    During covered business hours

  • 15 minutes

    24x7 on-call

    P1 incidents

P1 · Critical15 minutes

Production database down, primary unreachable, data corruption risk, or active failover event.

P2 · High30 minutes

Severe latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.

P3 · Medium60 minutes

Non-critical slow query regression, staging issue, backup warning, or replication check alert.

P4 · Low90 minutes

Configuration question, index advisory, planned schema review, or general operational request.

Our engineering team is in India; business-hours coverage is Mon–Fri 09:00–18:00 IST (UTC+5:30), and 24x7 on-call is available under your service agreement.

Initial-response targets, not resolution guarantees. The target for your engagement is set in your service agreement.

What happens on a P1 page

  1. Page

    You page the on-call engineer

    Through the escalation path your service agreement names.

  2. Triage

    Root cause from INFO, SLOWLOG, and Prometheus metrics

    Hot keys, slow scripts, memory pressure, and replica full syncs traced to the key or setting behind them.

  3. Mitigate

    Stabilize first, from the runbook

    Fail over to a current replica, close the offending client connections, or shed load, then fix the cause once production is steady.

  4. After

    A review after every P1

    What happened, why, and the change that stops it happening again.

Before and between incidents

  • Your setup, written down firstDuring onboarding we record your Dragonfly versions, flags, replication layout, failover method, and snapshot schedule, so an incident starts with context.
  • One escalation path, in writingYour service agreement names the on-call contact, the hours, and the Dragonfly deployments covered.
  • Reviews between incidentsWe review memory headroom, hot keys, replica lag, and snapshot restores, and report open risks with recommended next steps.
  • Version dates trackedWe track Dragonfly and Dragonfly Operator releases for the versions you run, and plan each upgrade from its release notes.

Process

How a Dragonfly engagement runs, step by step

Written findings come before any change. Your team approves production changes, except routine actions you have pre-approved.

  1. Scoping call

    Your Dragonfly deployments, versions, platforms, and what you need covered.

  2. Read-only review under NDA

    Our engineers use named ACL users with only the permissions the review needs, then read your flags, INFO, SLOWLOG, replication state, and snapshot schedule.

  3. A written report before any change

    Each finding comes with the change we propose, how we will measure it, and a way to undo it (a rollback plan).

  4. Changes, then handover

    We rehearse risky changes on a replica or a copy, apply them in the windows you approve, measure them against the baseline, and hand over updated operating instructions (runbooks).

Ways to work

Choose the Dragonfly service your team needs

Start with the responsibility you need covered. Each engagement has its own scope, deliverables, access requirements, and acceptance criteria.

Where your Dragonfly runs, and the tools around it

Your team and ours

What a managed Dragonfly service still leaves to your team

Managed cloud databases automate much of the infrastructure layer, but your team still owns query performance, capacity, cost, and incident decisions.

Who runs each part of Dragonfly on Dragonfly Cloud and on your own servers or Kubernetes
QuestionManaged cloud serviceYour own servers or Kubernetes
Servers, patches, and upgradesDragonfly Cloud runs them.Your team, or JusDB under your agreement.
Snapshots and restoresManual and scheduled backups are built in. Testing a restore is still your team's job.You set --snapshot_cron and --dir. By default, Dragonfly saves a snapshot only when it shuts down.
FailoverBuilt in once you add replicas. Your application still has to reconnect cleanly.You run Redis Sentinel or the Dragonfly Operator, because Dragonfly does not fail over by itself.
Memory and evictionYours. You pick No Eviction or Cache for the data store.Yours. Cache mode is off by default, so a full node rejects writes.
Scaling past one nodeDragonfly Swarm shards the data and moves slots for you, and needs Redis Cluster clients.Multi-shard Dragonfly Cluster has no control plane, so failover and slot moves are yours to build.
License termsYour Dragonfly Cloud agreement with the vendor applies.BSL 1.1 allows production use within your own product or service, but not an in-memory data store offering or a hosted Dragonfly service for others.

Your team keeps control

  • Set business priorities, application requirements, and release plans
  • Approve production changes, except routine actions you have pre-approved
  • Own your cloud accounts, access policies, and vendor relationships
  • Decide when maintenance can happen and how quickly service must recover
  • Move the work in-house or to another provider after your agreement's notice period, with your data returned or deleted and the transition help your agreement sets out (Terms, section 8)

JusDB handles the agreed database work

  • Monitor database health, investigate alerts, and involve the right people
  • Review query performance, replication, capacity, and backup health
  • Carry out approved changes and update the operating instructions they affect
  • Report completed work, open risks, and recommended next steps

Weighing Dragonfly Cloud against running Dragonfly yourself? We compare both against your workload on a scoping call.

Book a 30-min scoping call (opens Google Calendar in a new tab)

Further reading

Redis guides that apply to Dragonfly

Dragonfly implements the Redis API, so these Redis guides apply. Each card notes where Dragonfly differs.

FAQ

Common Dragonfly questions

What buyers ask about Dragonfly, Redis compatibility, Redis Cluster, and support hours.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

What is Dragonfly?

JusDB works with Dragonfly, an in-memory data store that speaks the Redis and Memcached protocols. It runs as one multi-threaded process that splits the keys into shards, each owned by a single thread (a shared-nothing design). Dragonfly uses the Business Source License 1.1 (BSL 1.1). The license allows production use within your own product or service. It does not allow an in-memory data store offering, or a hosted Dragonfly service for others. Each release converts to the Apache License 2.0 on its change date or four years after it ships, whichever comes first (September 2030 for 2.0.0). Your legal team should confirm what applies.

Is Dragonfly a drop-in replacement for Redis?

Not for every workload, so JusDB checks yours before any cutover. Redis client libraries connect to Dragonfly over the same protocol. It does not support Redis Functions, module loading, or commands such as SWAPDB. Its Lua scripts must declare every key they touch, unless a flag allows otherwise. It also has no append-only file (AOF), so recovery depends on snapshots and replicas.

How does Dragonfly compare to a Redis Cluster?

JusDB compares the two against your workload. Redis Cluster spreads keys across several nodes and limits multi-key commands to keys in one hash slot. One Dragonfly node uses every core it is given and keeps single-node behavior for multi-key commands. Its emulated cluster mode (--cluster_mode=emulated) lets Redis Cluster clients connect to that node. Past one node, Dragonfly Swarm in Dragonfly Cloud shards the data, while self-managed Dragonfly Cluster has no control plane for failover or rebalancing.

Do you offer 24/7 Dragonfly support?

Yes. JusDB provides 24x7 on-call for Dragonfly under your service agreement; without it, coverage is business hours. Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

Next step

Talk to a Dragonfly engineer about your databases

Tell us what is slow, fragile, or due to change. The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance, subject to availability: mutual NDA before read-only access, a prioritized report within one week after access is ready, and no obligation.

NDA before access, read-only by default, and written scope first