<!doctype html>
<html lang="en" dir="ltr" class="mdx-wrapper mdx-page plugin-pages plugin-id-default" data-has-hydrated="false">
<head>
<meta charset="UTF-8">
<meta name="generator" content="Docusaurus v2.4.3">
<title data-rh="true">Apache Druid Community | Apache® Druid</title><meta data-rh="true" name="viewport" content="width=device-width,initial-scale=1"><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" name="twitter:image" content="https://druid.apache.org/img/druid_nav.png"><meta data-rh="true" property="og:url" content="https://druid.apache.org/community/"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docusaurus_tag" content="default"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="docsearch:docusaurus_tag" content="default"><meta data-rh="true" property="og:title" content="Apache Druid Community | Apache® Druid"><meta data-rh="true" name="description" content="Community"><meta data-rh="true" property="og:description" content="Community"><link data-rh="true" rel="icon" href="/img/favicon.png"><link data-rh="true" rel="canonical" href="https://druid.apache.org/community/"><link data-rh="true" rel="alternate" href="https://druid.apache.org/community/" hreflang="en"><link data-rh="true" rel="alternate" href="https://druid.apache.org/community/" hreflang="x-default"><link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-131010415-1"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","UA-131010415-1",{})</script>





<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.4/clipboard.min.js"></script><link rel="stylesheet" href="/assets/css/styles.4b88a1d0.css">
<link rel="preload" href="/assets/js/runtime~main.5bfad63a.js" as="script">
<link rel="preload" href="/assets/js/main.d6cc924f.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}return t}()||function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region" aria-label="Skip to main content"><a class="skipToContent_fXgn" href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><nav aria-label="Main" class="navbar navbar--fixed-top navbar--dark"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Toggle navigation bar" aria-expanded="false" class="navbar__toggle clean-btn" type="button"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/druid_nav.png" alt="Apache® Druid" class="themedImage_ToTc themedImage--dark_i4oU"></div></a></div><div class="navbar__items navbar__items--right"><a class="navbar__item navbar__link" href="/technology">Technology</a><a class="navbar__item navbar__link" href="/use-cases">Use Cases</a><a class="navbar__item navbar__link" href="/druid-powered">Powered By</a><a class="navbar__item navbar__link" href="/docs/latest/design/">Docs</a><a class="navbar__item navbar__link" href="/community/">Community</a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Apache®</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://apachecon.com/?ref=druid.apache.org" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship<svg width="12" height="12" aria-hidden="true" viewBox="0 0 24 24" class="iconExternalLink_nPIU"><path fill="currentColor" d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"></path></svg></a></li></ul></div><a class="navbar__item navbar__link" href="/downloads/">Download</a><div class="searchBox_ZlJk"><div class="navbar__search"><span aria-label="expand searchbar" role="button" class="search-icon" tabindex="0"></span><input type="search" id="search_input_react" placeholder="Loading..." aria-label="Search" class="navbar__search-input search-bar" disabled=""></div></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div id="__docusaurus_skipToContent_fallback" class="main-wrapper mainWrapper_z2l0"><main class="container container--fluid margin-vert--lg"><div class="row mdxPageWrapper_j9I6"><div class="col col--8"><article><h2 class="anchor anchorWithStickyNavbar_LWe7" id="community">Community<a href="#community" class="hash-link" aria-label="Direct link to Community" title="Direct link to Community">​</a></h2><p>Most discussion about Druid happens over <a href="/community/join-slack?v=1">Slack</a>, <a href="https://github.com/apache/druid" target="_blank" rel="noopener noreferrer">GitHub</a>, and the <a href="https://lists.apache.org/list.html?dev@druid.apache.org" target="_blank" rel="noopener noreferrer">Apache Dev list</a>, but those aren&#x27;t the only way to interact with the Druid
community. We also do chat, meetups, and more.</p><p>Check out the following resources if you&#x27;re looking for help, to discuss Druid development, or just stay up to date:</p><ul><li><strong>Slack:</strong> Many users and committers are present on Apache Druid Slack. Use this link to join and invite others: <a href="/community/join-slack?v=1">https://druid.apache.org/community/join-slack</a>. This is the perfect place to ask for help if you need it!</li><li><strong>GitHub:</strong> Star us at <a href="https://github.com/apache/druid" target="_blank" rel="noopener noreferrer">apache/druid</a> and use this to follow Druid development, raise
issues, or contribute pull requests. If you&#x27;re interested in development, please see the <a href="#contributing">Contributing</a>
section below for details on our development process.</li><li><strong>Development mailing list:</strong> <a href="https://lists.apache.org/list.html?dev@druid.apache.org" target="_blank" rel="noopener noreferrer">dev@druid.apache.org</a> for
discussion about project development.</li><li><strong>Twitter:</strong> Follow us on Twitter at <a href="https://twitter.com/druidio" target="_blank" rel="noopener noreferrer">@druidio</a>.</li></ul><p>Also check out:</p><ul><li><strong>User mailing list:</strong> <a href="https://groups.google.com/forum/#!forum/druid-user" target="_blank" rel="noopener noreferrer">druid-user@googlegroups.com</a> for general
discussion, questions, and announcements.</li><li><strong>LinkedIn</strong> Connect with other Apache Druid professionals in the <a href="https://www.linkedin.com/groups/8791983/" target="_blank" rel="noopener noreferrer">LinkedIn group</a>.</li><li><strong>Meetups:</strong> Check out <a href="https://www.meetup.com/topics/apache-druid/" target="_blank" rel="noopener noreferrer">Apache Druid on meetup.com</a> for links to regular
meetups in cities all over the world.</li><li><strong>StackOverflow:</strong> While the user mailing list is the primary resource for asking questions, if you prefer
StackOverflow, make sure to tag your question with <code>druid</code> or <code>apache-druid</code>.</li><li><strong>Linen:</strong> Check out the <a href="https://www.linen.dev/s/apache-druid/c/troubleshooting" target="_blank" rel="noopener noreferrer">Apache Druid community on Linen</a> for a digital archive of Apache Druid Slack threads.
While Slack limits message history to the last 90 days, you can continue to access older threads on Linen.</li><li><strong>Struct:</strong> Check out <a href="https://druid.struct.ai/kb" target="_blank" rel="noopener noreferrer">Apache Druid on Struct</a> for AI-generated knowledge base from Apache Druid Slack threads.
Similar to Linen, Struct archives Slack threads so that you can continue to access messages beyond Slack&#x27;s 90 day retention period.</li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="getting-help">Getting help<a href="#getting-help" class="hash-link" aria-label="Direct link to Getting help" title="Direct link to Getting help">​</a></h2><p>The best place to get a wide variety of help about Druid is via <code>#druid</code> on the Apache Slack team. There is also a druid user
google group <a href="https://groups.google.com/forum/#!forum/druid-user" target="_blank" rel="noopener noreferrer">druid-user@googlegroups.com</a> however slack is the preferred way to get help. You can also report issues and problems, or suggest
new features, on <a href="https://github.com/apache/druid" target="_blank" rel="noopener noreferrer">GitHub</a>.</p><p>Third party companies also provide commercial support and services for Druid, including:</p><ul><li><a href="https://www.cloudera.com/" target="_blank" rel="noopener noreferrer">Cloudera</a></li><li><a href="https://datumo.io/" target="_blank" rel="noopener noreferrer">Datumo</a></li><li><a href="https://www.deep.bi/solutions/apache-druid" target="_blank" rel="noopener noreferrer">Deep.BI</a></li><li><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></li><li><a href="https://www.rilldata.com/" target="_blank" rel="noopener noreferrer">Rill Data</a></li></ul><h2 class="anchor anchorWithStickyNavbar_LWe7" id="contributing">Contributing<a href="#contributing" class="hash-link" aria-label="Direct link to Contributing" title="Direct link to Contributing">​</a></h2><p>Druid is a community-led project and we are delighted to receive contributions
of anything from minor fixes to big new features.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="what-to-work-on">What to work on<a href="#what-to-work-on" class="hash-link" aria-label="Direct link to What to work on" title="Direct link to What to work on">​</a></h3><p>If you have an itch to scratch, then by all means do that! Fixing bugs you run
into, or adding features you need, are both immensely helpful.</p><p>If you&#x27;re looking for some starter projects, we maintain a <a href="https://github.com/apache/druid/issues?q=is%3Aopen+is%3Aissue+label%3AStarter" target="_blank" rel="noopener noreferrer">list of issues</a> suitable
for new developers.</p><p>There are plenty of ways to help outside writing Druid code. <em>Code review of pull requests</em>
(even if you are not a committer), feature suggestions, reporting bugs, <a href="/docs/latest/design">documentation</a>
and usability feedback all matter immensely. Another big way to help is
through <a href="/libraries">client libraries</a>, which are
available in a variety of languages. If you develop a new one, we&#x27;ll be happy
to include it in the list.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="getting-your-changes-accepted">Getting your changes accepted<a href="#getting-your-changes-accepted" class="hash-link" aria-label="Direct link to Getting your changes accepted" title="Direct link to Getting your changes accepted">​</a></h3><p>Patches to Druid are done through <a href="https://github.com/apache/druid/pulls" target="_blank" rel="noopener noreferrer">GitHub pull requests</a>.</p><p>Pull requests require one approval (+1) from an established committer on code and text (for documentation) levels. The
exception is major architectural changes or API changes, and/or changes to</p><ul><li>HTTP requests and responses (e. g. a new HTTP endpoint)</li><li><a href="/docs/latest/development/modules">Interfaces for extensions</a></li><li>Server configuration (e. g. altering the behavior of a config property)</li><li>Emitted metrics</li><li>Other major changes, judged by the discretion of Druid committers</li></ul><p>warrant additional design and compatibility review. Such pull requests require design approvals from three different
committers (one of them could also be the author of the pull request). For those, it can help to discuss things
on the Druid development list <a href="https://lists.apache.org/list.html?dev@druid.apache.org" target="_blank" rel="noopener noreferrer">dev@druid.apache.org</a> or a github issue beforehand.</p><p>In general please follow the <a href="https://github.com/apache/druid/blob/master/CONTRIBUTING.md" target="_blank" rel="noopener noreferrer">contributing guidelines</a>
when sending in pull requests. This will help review proceed as quickly as
possible.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="testing">Testing<a href="#testing" class="hash-link" aria-label="Direct link to Testing" title="Direct link to Testing">​</a></h3><p>All Pull Requests are automatically tested through <a href="https://github.com/apache/druid/actions" target="_blank" rel="noopener noreferrer">GitHub Actions</a> on both AMD64 and ARM64 architectures.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="committers">Committers<a href="#committers" class="hash-link" aria-label="Direct link to Committers" title="Direct link to Committers">​</a></h3><p>Committers are collectively responsible for Druid&#x27;s technical management. This involves
setting the direction of the project, contributing code, and reviewing code contributed
by others.</p><p>You don&#x27;t need to be a committer to contribute- pull requests are welcome from anyone.</p><table><thead><tr><th>Name</th><th>Organization</th></tr></thead><tbody><tr><td><a href="https://github.com/abhishekagarwal87" target="_blank" rel="noopener noreferrer">Abhishek Agarwal</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/AlexanderSaydakov" target="_blank" rel="noopener noreferrer">Alexander Saydakov</a></td><td><a href="https://www.verizonmedia.com/" target="_blank" rel="noopener noreferrer">Verizon Media</a></td></tr><tr><td><a href="https://github.com/AmatyaAvadhanula" target="_blank" rel="noopener noreferrer">Amatya Avadhanula</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/a2l007" target="_blank" rel="noopener noreferrer">Atul Mohan</a></td><td><a href="https://www.yahoo.com/" target="_blank" rel="noopener noreferrer">Yahoo</a></td></tr><tr><td><a href="https://github.com/asdf2014" target="_blank" rel="noopener noreferrer">Benedict Jin</a></td><td><a href="https://www.alibaba.com/" target="_blank" rel="noopener noreferrer">Alibaba</a></td></tr><tr><td><a href="https://github.com/drcrallen" target="_blank" rel="noopener noreferrer">Charles Allen</a></td><td><a href="https://www.snap.com/en-US/" target="_blank" rel="noopener noreferrer">Snap</a></td></tr><tr><td><a href="https://github.com/ccaominh" target="_blank" rel="noopener noreferrer">Chi Cao Minh</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/clintropolis" target="_blank" rel="noopener noreferrer">Clint Wylie</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/glasser" target="_blank" rel="noopener noreferrer">David Glasser</a></td><td><a href="https://apollographql.com/" target="_blank" rel="noopener noreferrer">Apollo GraphQL</a></td></tr><tr><td><a href="https://github.com/dclim" target="_blank" rel="noopener noreferrer">David Lim</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/gaodayue" target="_blank" rel="noopener noreferrer">Daoyue Gao</a></td><td><a href="http://www.meituan.com/" target="_blank" rel="noopener noreferrer">Meituan</a></td></tr><tr><td><a href="https://github.com/Dylan1312" target="_blank" rel="noopener noreferrer">Dylan Wylie</a></td><td><a href="https://www.spotx.tv/" target="_blank" rel="noopener noreferrer">SpotX</a></td></tr><tr><td><a href="https://github.com/egor-ryashin" target="_blank" rel="noopener noreferrer">Egor Rashin</a></td><td><a href="https://www.rilldata.com/" target="_blank" rel="noopener noreferrer">Rill Data</a></td></tr><tr><td><a href="https://github.com/cheddar" target="_blank" rel="noopener noreferrer">Eric Tschetter</a></td><td><a href="https://www.splunk.com/" target="_blank" rel="noopener noreferrer">Splunk</a></td></tr><tr><td><a href="https://github.com/fjy" target="_blank" rel="noopener noreferrer">Fangjin Yang</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/Fokko" target="_blank" rel="noopener noreferrer">Fokko Driesprong</a></td><td><a href="https://godatadriven.com/" target="_blank" rel="noopener noreferrer">GoDataDriven</a></td></tr><tr><td><a href="https://github.com/FrankChen021" target="_blank" rel="noopener noreferrer">Frank Chen</a></td><td><a href="https://shopee.sg/" target="_blank" rel="noopener noreferrer">Shopee</a></td></tr><tr><td><a href="https://github.com/kamaci" target="_blank" rel="noopener noreferrer">Furkan Kamaci</a></td><td><a href="https://lagom.ai/" target="_blank" rel="noopener noreferrer">Lagom</a></td></tr><tr><td><a href="https://github.com/gianm" target="_blank" rel="noopener noreferrer">Gian Merlino</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/himanshug" target="_blank" rel="noopener noreferrer">Himanshu Gupta</a></td><td><a href="https://www.splunk.com/" target="_blank" rel="noopener noreferrer">Splunk</a></td></tr><tr><td><a href="https://github.com/jihoonson" target="_blank" rel="noopener noreferrer">Jihoon Son</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/jon-wei" target="_blank" rel="noopener noreferrer">Jonathan Wei</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/julianhyde" target="_blank" rel="noopener noreferrer">Julian Hyde</a></td><td><a href="https://looker.com/" target="_blank" rel="noopener noreferrer">Looker</a></td></tr><tr><td><a href="https://github.com/junrao" target="_blank" rel="noopener noreferrer">Jun Rao</a></td><td><a href="https://www.confluent.io/" target="_blank" rel="noopener noreferrer">Confluent</a></td></tr><tr><td><a href="https://github.com/kaijianding" target="_blank" rel="noopener noreferrer">Kaijian Ding</a></td><td><a href="https://www.alibaba.com/" target="_blank" rel="noopener noreferrer">Alibaba</a></td></tr><tr><td><a href="https://github.com/cryptoe" target="_blank" rel="noopener noreferrer">Karan Kumar</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/kfaraz" target="_blank" rel="noopener noreferrer">Kashif Faraz</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/kurtyoung" target="_blank" rel="noopener noreferrer">Kurt Young</a></td><td><a href="https://www.alibaba.com/" target="_blank" rel="noopener noreferrer">Alibaba</a></td></tr><tr><td><a href="https://github.com/LakshSingla" target="_blank" rel="noopener noreferrer">Laksh Singla</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/binlijin" target="_blank" rel="noopener noreferrer">Lijin Bin</a></td><td><a href="https://www.alibaba.com/" target="_blank" rel="noopener noreferrer">Alibaba</a></td></tr><tr><td><a href="https://github.com/capistrant" target="_blank" rel="noopener noreferrer">Lucas Capistrant</a></td><td><a href="https://www.target.com/" target="_blank" rel="noopener noreferrer">Target</a></td></tr><tr><td><a href="https://github.com/mcbrewster" target="_blank" rel="noopener noreferrer">Maggie Brewster</a></td><td><a href="https://www.imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/mistercrunch" target="_blank" rel="noopener noreferrer">Maxime Beauchemin</a></td><td><a href="http://preset.io/" target="_blank" rel="noopener noreferrer">Preset</a></td></tr><tr><td><a href="https://github.com/maytasm" target="_blank" rel="noopener noreferrer">Maytas Monsereenusorn</a></td><td><a href="https://www.netflix.com/" target="_blank" rel="noopener noreferrer">Netflix</a></td></tr><tr><td><a href="https://github.com/michaelschiff" target="_blank" rel="noopener noreferrer">Michael Schiff</a></td><td><a href="https://www.adobe.com/" target="_blank" rel="noopener noreferrer">Adobe</a></td></tr><tr><td><a href="https://github.com/QiuMM" target="_blank" rel="noopener noreferrer">Mingming Qiu</a></td><td><a href="https://bytedance.com/" target="_blank" rel="noopener noreferrer">Bytedance</a></td></tr><tr><td><a href="https://github.com/b-slim" target="_blank" rel="noopener noreferrer">Mohamed Slim Bouguerra</a></td><td><a href="https://www.linkedin.com/" target="_blank" rel="noopener noreferrer">LinkedIn</a></td></tr><tr><td><a href="https://github.com/navis" target="_blank" rel="noopener noreferrer">Navis Ryu</a></td><td><a href="https://www.sktelecom.com/index.html" target="_blank" rel="noopener noreferrer">SK Telecom</a></td></tr><tr><td><a href="https://github.com/niketh" target="_blank" rel="noopener noreferrer">Niketh Sabbineni</a></td><td><a href="https://www.verizonmedia.com/" target="_blank" rel="noopener noreferrer">Verizon Media</a></td></tr><tr><td><a href="https://github.com/nishantmonu51" target="_blank" rel="noopener noreferrer">Nishant Bangarwa</a></td><td><a href="https://www.rilldata.com/" target="_blank" rel="noopener noreferrer">Rill Data</a></td></tr><tr><td><a href="https://github.com/pjain1" target="_blank" rel="noopener noreferrer">Parag Jain</a></td><td><a href="https://www.rilldata.com/" target="_blank" rel="noopener noreferrer">Rill Data</a></td></tr><tr><td><a href="https://github.com/ptgoetz" target="_blank" rel="noopener noreferrer">P. Taylor Goetz</a></td><td><a href="https://www.epam.com/" target="_blank" rel="noopener noreferrer">EPAM</a></td></tr><tr><td><a href="https://github.com/paul-rogers" target="_blank" rel="noopener noreferrer">Paul Rogers</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/rohangarg" target="_blank" rel="noopener noreferrer">Rohan Garg</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/leventov" target="_blank" rel="noopener noreferrer">Roman Leventov</a></td><td><a href="https://www.snap.com/en-US/" target="_blank" rel="noopener noreferrer">Snap</a></td></tr><tr><td><a href="https://github.com/samarthjain" target="_blank" rel="noopener noreferrer">Samarth Jain</a></td><td><a href="https://www.netflix.com/" target="_blank" rel="noopener noreferrer">Netflix</a></td></tr><tr><td><a href="https://github.com/sthetland" target="_blank" rel="noopener noreferrer">Steve Hetland</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/suneet-s" target="_blank" rel="noopener noreferrer">Suneet Saldanha</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/surekhasaharan" target="_blank" rel="noopener noreferrer">Surekha Saharan</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/tejaswini-imply" target="_blank" rel="noopener noreferrer">Tejaswini Bandlamudi</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/vogievetsky" target="_blank" rel="noopener noreferrer">Vadim Ogievetsky</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/vtlim" target="_blank" rel="noopener noreferrer">Victoria Lim</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr><tr><td><a href="https://github.com/xvrl" target="_blank" rel="noopener noreferrer">Xavier Léauté</a></td><td><a href="https://www.confluent.io/" target="_blank" rel="noopener noreferrer">Confluent</a></td></tr><tr><td><a href="https://github.com/zhangxinyu1" target="_blank" rel="noopener noreferrer">Xinyu Zhang</a></td><td><a href="https://www.360.cn/" target="_blank" rel="noopener noreferrer">Qihoo 360</a></td></tr><tr><td><a href="https://github.com/zhangyue19921010" target="_blank" rel="noopener noreferrer">Yue Zhang</a></td><td></td></tr><tr><td><a href="https://github.com/zachjsh" target="_blank" rel="noopener noreferrer">Zach Sherman</a></td><td><a href="https://imply.io/" target="_blank" rel="noopener noreferrer">Imply</a></td></tr></tbody></table><h3 class="anchor anchorWithStickyNavbar_LWe7" id="becoming-a-committer">Becoming a committer<a href="#becoming-a-committer" class="hash-link" aria-label="Direct link to Becoming a committer" title="Direct link to Becoming a committer">​</a></h3><p>If you&#x27;d like to become a committer, that&#x27;s great! Please contact one of the
existing committers for a walk through the process. Basically, what we&#x27;re
looking for is an interest in ongoing contributions to Druid.</p><h3 class="anchor anchorWithStickyNavbar_LWe7" id="general-committer-guidelines">General committer guidelines<a href="#general-committer-guidelines" class="hash-link" aria-label="Direct link to General committer guidelines" title="Direct link to General committer guidelines">​</a></h3><p>If you are an official Druid committer then congratulations! You are part of a fantastic group of people. Here are some guidelines to follow to help ensure the Druid project continues to grow and improve:</p><ol><li>You can merge your own pull request if it fits the rest of the criteria. A common thing to see is &quot;+1 after travis&quot; from other committers.</li><li>A pull request should have at least one +1 from a committer who is not the author, on the &quot;code/textual&quot; level of review.</li><li>Pull requests which have just one +1 from a committer couldn&#x27;t be merged earlier than after 3 working days since PR submission.</li><li>A pull request with just one +1 could be merged only by (or in coordination with) the committer who provided the review. Because the reviewer may think that the PR is complex or risky enough that needs another pair of eyes to look at it. If this is the case, the first reviewer should indicate this in the PR approval message.</li><li>If a pull request has two or more +1&#x27;s from committers who are not the author, it could be merged immediately and by any committer. But still, enough time since the PR submission should pass to give folks a reasonable chance to indicate a desire to comment on the pull request. AKA: don&#x27;t merge a pull request that was submitted Friday evening until at least 1~2 regular work days have passed. Use good judgement here.</li><li>Major architectural and backwards incompatible changes, or changes which have long-term maintenance consequences (see examples in <a href="#getting-your-changes-accepted">the &quot;Getting your changes accepted&quot; section above</a>), should have at least three +1&#x27;s from committers, on the &quot;design&quot; level of review. One approval could be from the author of the PR. The first committer who indicates that a PR needs design review should add the <code>Design Review</code> tag to such a pull request.</li><li>Travis-CI should pass or have some <strong>very</strong> good reason why it won&#x27;t pass for a pull request.</li><li>You reasonably believe that all comments have been addressed.</li><li>You are expected to be the champion for your own pull requests.</li><li>Being a champion on a pull request can be a significant undertaking depending on the size of the code change and what parts of the code it touches. It may require communicating with other developers, reconciling differences, organizing community feedback, and/or following up with people who have commented in a pull request to ensure comments have been addressed.</li><li>Sometimes code is presented as a work-in-progress or as a point of discussion. Use the <code>WIP</code> or <code>Discuss</code> tags on a pull request in such a case.</li><li>If a pull request you are championing is taking longer than expected to merge, be sure to raise the issue in the developer sync.</li><li>Limit the number of pull requests you are championing at the same time.</li><li>Prioritize code reviews to look at pull requests that are blockers for the next release (see the Milestone marker on the pull request)</li><li>Help serve as champion for pull requests that originate from new committers.</li><li>If you feel a pull request is required for the next release, mark it as such in the Milestone of the pull request.</li><li>Do not comment on a pull request unless you are willing to follow up on the edits.</li><li>Give priority to getting older pull requests merged. (Either as their champion or as an active commenter)</li><li>And most importantly.. the PMC desires to ensure a positive and effective developer experience! If you find that things are not functioning to your expectations, please raise the issue.</li></ol><p>Remember, we all want to see this project thrive!</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="governance">Governance<a href="#governance" class="hash-link" aria-label="Direct link to Governance" title="Direct link to Governance">​</a></h2><p>The PMC (Project Management Committee) is responsible for the administrative
aspects of the Druid project. The responsibilities of the PMC include:</p><ul><li>Approving releases</li><li>Nominating new committers</li><li>Maintaining the project&#x27;s shared resources, including the github account,
mailing lists, websites, social media channels, etc.</li><li>Maintaining guidelines for the project</li></ul></article></div><div class="col col--2"><div class="tableOfContents_bqdL thin-scrollbar"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#community" class="table-of-contents__link toc-highlight">Community</a></li><li><a href="#getting-help" class="table-of-contents__link toc-highlight">Getting help</a></li><li><a href="#contributing" class="table-of-contents__link toc-highlight">Contributing</a><ul><li><a href="#what-to-work-on" class="table-of-contents__link toc-highlight">What to work on</a></li><li><a href="#getting-your-changes-accepted" class="table-of-contents__link toc-highlight">Getting your changes accepted</a></li><li><a href="#testing" class="table-of-contents__link toc-highlight">Testing</a></li><li><a href="#committers" class="table-of-contents__link toc-highlight">Committers</a></li><li><a href="#becoming-a-committer" class="table-of-contents__link toc-highlight">Becoming a committer</a></li><li><a href="#general-committer-guidelines" class="table-of-contents__link toc-highlight">General committer guidelines</a></li></ul></li><li><a href="#governance" class="table-of-contents__link toc-highlight">Governance</a></li></ul></div></div></div></main></div><footer class="footer"><div class="container container-fluid"><div class="footer__bottom text--center"><div class="margin-bottom--sm"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--light_HNdA footer__logo"><img src="/img/favicon.png" class="themedImage_ToTc themedImage--dark_i4oU footer__logo"></div><div class="footer__copyright">Copyright © 2023 Apache Software Foundation. Except where otherwise noted, licensed under CC BY-SA 4.0. Apache Druid, Druid, and the Druid logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</div></div></div></footer></div>
<script src="/assets/js/runtime~main.5bfad63a.js"></script>
<script src="/assets/js/main.d6cc924f.js"></script>
</body>
</html>