Real-time analytics support

Apache Druid Support for Self-Managed, Kubernetes and Imply Clusters

Last reviewed by Tyler Eastridge

AceMQ supports Apache Druid 24/7 across Americas, EMEA and APAC: self-managed clusters, Druid on Kubernetes and Imply deployments, with Kafka, Kinesis and batch ingestion. Most calls start with one of three problems: streaming ingestion running behind, queries that slow down as segments pile up, or segments that are built but never become queryable.

24/7 Apache Druid support with response targets from 15 minutes, by plan. Quote replies within 1 hour.

Support quotes answered within 1 hour, by a senior engineer.

Planning a build, upgrade or migration instead? See AceMQ Apache Druid consulting and services.

160+
Customers supported
10+
Years in production support
40+
Sev 1 incidents handled a year
24/7
Americas, EMEA and APAC
1hour
Quote reply

Customers

  • Microsoft
  • Henry Schein
  • Enbridge
  • Gojek

Partners

  • Broadcom
  • Redis
  • VMware Tanzu
  • OSSeva

Incident Triage

Problems we fix every week

Druid trouble we are called on most, each row naming the supervisor endpoint, metric or system table an engineer opens first.

Common Apache Druid production problems and how AceMQ resolves them
Symptom you're seeingWhat we check first
Streaming ingestion falls behindWe read the supervisor with GET /druid/indexer/v1/supervisor/<id>/status and /stats, then metrics ingest/kafka/lag, ingest/events/thrownAway and ingest/events/unparseable. Rejected or unparseable rows explain data that is "missing" while lag looks fine; task restarts explain lag that keeps coming back. We tune taskCount, taskDuration, maxRowsPerSegment and intermediateHandoffPeriod from the numbers.
Queries slow down over monthsWe read query/time, query/wait/time and segment/scan/pending, then compare druid.processing.numThreads and druid.processing.numMergeBuffers with the concurrency of your dashboards. EXPLAIN PLAN FOR shows whether SQL compiled to a native query or fell back to something expensive such as a scan with a post-aggregation on a wide table.
Segment count and size driftRun SELECT datasource, COUNT(*) AS segs, AVG(size)/1000000 AS avg_mb FROM sys.segments GROUP BY 1 to see the shape. Many small segments need compaction; a few huge ones need smaller time chunks. We check segment/unavailable/count and segment/underReplicated/count on the Coordinator to find data that is published but not served.
Historicals fill upsegment/usedPercent and druid.server.maxSize against druid.segmentCache.locations, then load rules and tier assignment (druid.server.tier). A loadByPeriod rule that no longer covers the window people query pushes hot data onto a cold tier.
Multi-stage engine (MSQ) queries failErrors such as NotEnoughMemory, TooManyWorkers and TaskStartTimeout map to task slot supply and memory per worker, not to the SQL. We size slots for ingestion and MSQ together so one cannot starve the other.
Handoff stalls on deep storageA rotated S3, GCS or Azure credential, a missing bucket permission, or a full volume stops segment pushes and then handoff. We check the task log for the push error and druid.storage.* settings, not the Coordinator first.
The metadata store becomes the bottleneckThe druid_segments table grows with unused segments. We schedule kill tasks (druid.coordinator.kill.on), check database indexes and latency, and review Overlord and Coordinator behaviour when the database is slow.
Upgrades take down ingestionDruid documents a rolling update order for its services; we follow it for your target version, drain streaming tasks first, and keep a rollback plan for metadata and segments.

Each fix is documented with the segment, task or load rule involved, so the same drift is spotted sooner next time.

Ingestion lagging or brokers erroring on every query? Request a quote and we reply within an hour.

Contact Us

Deployment coverage

Which Druid deployments does AceMQ support, and who covers what?

DeploymentWhat AceMQ coversWhat the vendor coversExcluded
Self-managed Apache Druid on VMs or bare metalIncident response, ingestion, compaction, tiering, sizing, security, upgradesNo vendor contract; the project lists community channels (druid.apache.org/community, read 17 Nov 2026)Hardware and OS faults outside the agreed scope
Druid on Kubernetes (Druid Operator)The same scope, plus pod sizing against heap and direct memory, storage classes, rolling update behaviourThe Kubernetes distribution vendor supports the platformControl-plane faults
Imply deploymentsQuery design, ingestion specs, segment layout, cost and capacity, escalation alongside ImplyImply supports its product under its terms (imply.io/support-maintenance-terms, read 17 Nov 2026)Product defects stay with Imply
Dependencies (Kafka or Kinesis, ZooKeeper, metadata database, deep storage)The Druid-side behaviour and the integrationEach vendor supports its own systemFaults inside those systems

Support options

Who provides enterprise support for Apache Druid? Project, Imply and independent support compared

Apache Druid is an Apache Software Foundation project with no vendor support contract. The project's community page lists third-party companies that sell commercial support and services, and names Imply among five. Independent support covers self-managed Druid and the behaviour around a vendor product.

Apache Druid project / Imply
AceMQ independent support
HelpApache Druid project: Slack, GitHub, mailing lists, Stack Overflow (Druid community page, read 17 Nov 2026)Imply: Support levels of Base, Standard and Mission-Critical
HelpPhone and email, one contract
Response targetsApache Druid project: NoneImply: Standard, 24x7: P1 in 4 hours, P2 in 1 day. Mission-Critical, 24x7: P1 in 1 hour, P2 in 4 hours (Imply support and maintenance terms, effective 1 Feb 2022, read 17 Nov 2026; check the current terms with Imply)
Response targetsResponse targets from 15 minutes, by plan, 24/7
ScopeApache Druid project: The softwareImply: Imply's product and what it supplies
ScopeAny Druid deployment, its ingestion, segments, queries and dependencies
PriceApache Druid project: FreeImply: By quote
Price$24,000 to $72,000 a year (USD), set by SLA, scope and deployment

What's Included

Everything in your Apache Druid support contract

Coordinator, overlord, broker, historical and middleManager roles, plus ingestion and deep storage, handled under one contract.

  • 01

    Emergency Incident Response

    Ingestion stopped, segments unavailable, brokers timing out, or a Coordinator that won't hold a stable view of the cluster. With response targets from 15 minutes, by plan, a senior engineer joins a live bridge with access to diagnose.

  • 02

    Root Cause Analysis

    Every P1 closes with a written RCA: what failed, why, the fix applied, and the ingestion spec, granularity, or capacity change that prevents recurrence. Delivered as standard, not on request.

  • 03

    Ingestion Pipeline Review

    Kafka and Kinesis supervisor specs, task count and duration sizing, late-arriving data handling, and the schema and rollup decisions that determine segment size long before anyone sees a slow query.

  • 04

    Segment & Compaction Strategy

    Segment granularity matched to retention and query patterns, auto-compaction configured with dedicated task capacity, and target segment sizing that keeps the Broker's fan-out cost manageable.

  • 05

    Cluster Sizing & Tiering

    Per-role JVM heap and direct memory tuning for Broker, Historical, MiddleManager, and Coordinator, plus hot and cold tier load rules that match where your queries actually land.

  • 06

    Upgrades & Migrations

    Rolling version upgrades across the full node set in the correct order, moves between self-managed and Imply, deep storage migrations, and migrations onto Druid from Elasticsearch or a warehouse.

Why AceMQ

Why analytics engineers rely on us for Druid

  • Named Engineers, Zero Cold Start

    The same senior engineers stay on your account. They know your tier layout, your supervisor specs, and your retention rules — so a P1 call opens with a hypothesis rather than a tour of your cluster.

  • No First-Line Triage Layer

    You reach a senior Druid engineer directly by phone, email, or Slack. Nobody collects details to hand off, and no escalation approval stands between you and someone who can read a supervisor payload.

  • We Understand the Whole Process Set

    Druid is six coordinating services with different memory models and failure modes. Most incidents are misattributed to the process that reported the error rather than the one that caused it — Historical capacity showing up as a Broker timeout, for instance.

  • Ingestion and Query, Not Just One

    Query performance in Druid is decided at ingestion time by granularity, rollup, and partitioning. We fix the spec that created the segments rather than tuning around the segments you already have.

  • Genuine Follow-the-Sun Coverage

    Round-the-clock coverage for customers in 26+ countries. Your 3am supervisor failure is someone's mid-afternoon — no overnight skeleton crew, no waiting for a region to wake up.

  • Full-Stack, Including the Dependencies

    We diagnose across Kafka, ZooKeeper, the metadata database, deep storage latency, the JVM, and Kubernetes. Druid rarely fails alone, and its dependencies fail in ways that look like Druid bugs.

Druid clusters we run support for

Self-managed clusters, Druid Operator on Kubernetes, Imply deployments, and sites where nothing may call out to AceMQ.

  • Apache Druid 38 and earlier releases (self-managed)
  • Imply Enterprise & Imply Polaris
  • Druid Operator on Kubernetes
  • OpenShift
  • AWS (EC2, EKS, S3 deep storage)
  • Microsoft Azure (AKS, Blob deep storage)
  • Google Cloud (GKE, GCS deep storage)
  • HDFS deep storage
  • ZooKeeper & PostgreSQL/MySQL metadata store
  • Kafka & Kinesis streaming ingestion
  • Bare metal & on-premise
  • Air-gapped / no outbound access

Version coverage

Versions we support

Versions we support
LineRelease listedDate
Apache Druid 3838.0.01 Oct 2026 (latest stable on druid.apache.org/downloads, read 17 Nov 2026)
Apache Druid 3737.0.08 May 2026 (previous major release branch)
Earlier Druid lines in productionAnyUpgrade path planned from your version, with a rehearsal on a copy of your ingestion specs

The download page does not state which release lines are maintained. We support what you run.

Escalation Path

Your first hour of an Apache Druid outage

When ingestion stops on a production datasource, the lag grows every minute, so that case runs on the shortest timer.

  1. From 15 min (by plan)first responseEmergencyIngestion halted on a production datasource, brokers failing every query, or segments reported unavailable
  2. 1 hourfirst responseCriticalStreaming lag beyond the freshness target, a historical tier full, multi-stage engine jobs failing for a critical load
  3. 4 hoursfirst responseHighA dashboard timing out on wide time ranges, unparseable rows climbing, handoff stalling on deep storage
  4. Next Dayfirst responseStandardCompaction policy, rollup and granularity design, tier layout, upgrade rehearsal

Response times follow your plan. Stopped ingestion is handled ahead of compaction questions, which can wait for the next business day.

Looking for engineers who know your datasources, tiers and supervisors? Request a quote or message us.

Contact Us

Pricing

What does AceMQ Apache Druid support cost?

Apache Druid support is generally $24,000–72,000 a year. The size follows your count of historicals, brokers and middleManagers, how many streaming supervisors run, whether you use hot and cold tiers, and the response level.

Figures are in US dollars (USD). Response targets start at 15 minutes by plan, 24/7, and we answer quote requests within 1 hour.

Support In Practice

Druid problems we have diagnosed

Apache Druid support and remediation work from AceMQ. Each card links to the full write-up: the cluster, what AceMQ diagnosed or changed, and the result.

1 / 4 case studies

All use cases

Support options

Four tiers of Apache Druid support.

AceMQ offers Apache Druid support in four tiers, each handing more of the day-to-day work to AceMQ: 24/7 support and incident management for clusters your team runs, proactive monitoring that catches supervisor lag, segment sprawl and full tiers first, managed Druid on your own infrastructure, and fully managed Druid on AceMQ infrastructure. Self-managed Druid, Imply Enterprise and Imply Polaris estates are covered.

  • Tier 1

    Apache Druid 24/7 Support & Incident Management

    Your data team runs Druid, we escalate

    Best for: Engineers who own the cluster and want a specialist when ingestion, segments or brokers fail.

  • Tier 2

    Apache Druid 24/7 Support with Proactive Monitoring

    Segment, compaction and lag reviews with you

    Best for: Teams noticing slow queries and growing segment counts who want drift caught on a schedule.

  • Tier 3

    Managed Apache Druid on Your Infrastructure

    We operate Druid services in your estate

    Best for: Organizations keeping historicals, brokers and deep storage on their own accounts without the staff to tend them.

  • Tier 4

    Fully Managed Apache Druid on AceMQ Infrastructure

    We run every Druid service for you

    Best for: Product teams who want real-time analytics queries available without managing ingestion tasks and tiers.

FAQ

Apache Druid support questions

Still have questions about Apache Druid? Email an Expert

Who provides enterprise support for Apache Druid?

The Apache Druid project sells no support; Imply and other firms on the community page do. AceMQ covers Druid you operate, with response from 15 minutes by plan, 24/7. A Sev 1 such as halted ingestion means an engineer on a bridge reading supervisor status.

Why is Druid streaming ingestion behind?

The supervisor shows whether tasks are failing and restarting, running out of slots, or rejecting rows. Check ingest/kafka/lag, task logs and ingest/events/unparseable before adding tasks.

Why are our Druid queries slowing down?

Usually segment count: many small segments mean more per-segment work for the Brokers and Historicals. Compaction and segment granularity are the fix, followed by processing thread and merge buffer sizing.

How big should Druid segments be?

Check the shape with sys.segments. We aim for segments sized to your query patterns and rows per segment, then compact to that; the right numbers depend on your data.

Why did enabling rollup make storage bigger?

Rollup only merges rows with identical dimension values. A high-cardinality dimension such as a request ID stops it merging anything.

How do we upgrade Druid safely?

Follow the documented service order, drain streaming tasks first, rehearse on a copy of your specs, and keep a rollback plan for the metadata store.

Do you support Druid with Kafka and Kinesis?

Yes. We tune supervisors, check offset handling and task slot supply, and set expectations about exactly-once delivery. When lag appears, we read task logs and unparseable counts before recommending more tasks.

What does a Druid health check include?

We review ingestion lag and rejection rates, segment size and count, compaction, tier capacity, query latency, metadata store and deep storage permissions. You get a written list ranked by production risk, with the query behind each item.

Can we pay for a Druid health check without signing for a year?

Yes. A health check, a compaction plan or an upgrade rehearsal can each be a stand-alone project with a fixed deliverable. If you want 24/7 cover and engineers who remember your specs and tiers, the annual plan builds on that work.

What should we expect to pay for Druid support?

Most annual contracts sit between $24,000 and $72,000 (USD). Inputs include the number of data servers and query servers, streaming supervisors from Kafka or Kinesis, storage tiers, whether Imply is in the mix, and the response target. Describe the cluster and we quote within 1 hour.

Let's talk

Druid Degrades on a Schedule Long Before It Breaks

Send us a sys.segments summary and the supervisor status for your slowest datasource. We reply within 1 business hour with what we would change first.

A senior Apache Druid engineer, not a sales queueQuote requests answered within 1 hourAd hoc engagements or an annual partnership

Production incident right now?Email an Apache Druid Architect