<!DOCTYPE html>
<html>

    <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon">
    <link rel="icon" href="/favicon.ico" type="image/x-icon">

    <title>Apache Storm 0.9.2 released</title>

    <!-- Bootstrap core CSS -->
    <link href="/assets/css/bootstrap.min.css" rel="stylesheet">
    <!-- Bootstrap theme -->
    <link href="/assets/css/bootstrap-theme.min.css" rel="stylesheet">

    <!-- Custom styles for this template -->
    <link rel="stylesheet" href="http://fortawesome.github.io/Font-Awesome/assets/font-awesome/css/font-awesome.css">
    <link href="/css/style.css" rel="stylesheet">
    <link href="/assets/css/owl.theme.css" rel="stylesheet">
    <link href="/assets/css/owl.carousel.css" rel="stylesheet">
    <script type="text/javascript" src="/assets/js/jquery.min.js"></script>
    <script type="text/javascript" src="/assets/js/bootstrap.min.js"></script>
    <script type="text/javascript" src="/assets/js/owl.carousel.min.js"></script>
    <script type="text/javascript" src="/assets/js/storm.js"></script>
    <!-- Just for debugging purposes. Don't actually copy these 2 lines! -->
    <!--[if lt IE 9]><script src="../../assets/js/ie8-responsive-file-warning.js"></script><![endif]-->
    
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!--[if lt IE 9]>
      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
    <![endif]-->
  </head>



    <body>

    <header>
  <div class="container-fluid">
     <div class="row">
          <div class="col-md-5">
            <a href="/index.html"><img src="/images/logo.png" class="logo" /></a>
          </div>
          <div class="col-md-5">
            
          </div>
          <div class="col-md-2">
            <a href="/downloads.html" class="btn-std btn-block btn-download">Download</a>
          </div>
        </div>
    </div>
</header>
<!--Header End-->
<!--Navigation Begin-->
<div class="navbar" role="banner">
  <div class="container-fluid">
      <div class="navbar-header">
          <button class="navbar-toggle" type="button" data-toggle="collapse" data-target=".bs-navbar-collapse">
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
        </div>
        <nav class="collapse navbar-collapse bs-navbar-collapse" role="navigation">
          <ul class="nav navbar-nav">
              <li><a href="/index.html" id="home">Home</a></li>
                <li><a href="/getting-help.html" id="getting-help">Getting Help</a></li>
                <li><a href="/about/integrates.html" id="project-info">Project Information</a></li>
                <li class="dropdown">
                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" id="documentation">Documentation <b class="caret"></b></a>
                    <ul class="dropdown-menu">
                      
                        
                          <li><a href="/releases/2.4.0/index.html">2.4.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.3.0/index.html">2.3.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.2.1/index.html">2.2.1</a></li>
                        
                      
                        
                          <li><a href="/releases/2.2.0/index.html">2.2.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.1.1/index.html">2.1.1</a></li>
                        
                      
                        
                          <li><a href="/releases/2.1.0/index.html">2.1.0</a></li>
                        
                      
                        
                          <li><a href="/releases/2.0.0/index.html">2.0.0</a></li>
                        
                      
                        
                          <li><a href="/releases/1.2.4/index.html">1.2.4</a></li>
                        
                      
                        
                          <li><a href="/releases/1.2.3/index.html">1.2.3</a></li>
                        
                      
                    </ul>
                </li>
                <li><a href="/talksAndVideos.html">Talks and Slideshows</a></li>
                <li class="dropdown">
                    <a href="#" class="dropdown-toggle" data-toggle="dropdown" id="contribute">Community <b class="caret"></b></a>
                    <ul class="dropdown-menu">
                        <li><a href="/contribute/Contributing-to-Storm.html">Contributing</a></li>
                        <li><a href="/contribute/People.html">People</a></li>
                        <li><a href="/contribute/BYLAWS.html">ByLaws</a></li>
                        <li><a href="/Powered-By.html">PoweredBy</a></li>
                    </ul>
                </li>
                <li><a href="/2021/10/14/storm211-released.html" id="news">News</a></li>
            </ul>
        </nav>
    </div>
</div>



    <div class="container-fluid">
        <div class="row">
            <div class="col-md-12">
                <div class="row">
                    <div class="col-md-3">
                        <ul class="news" id="news-list">
                            
                      		<li><a href="/2021/10/14/storm211-released.html">Apache Storm 2.1.1 Released</a></li>
                    		
                      		<li><a href="/2021/10/11/storm221-released.html">Apache Storm 2.2.1 Released</a></li>
                    		
                      		<li><a href="/2021/10/11/storm124-released.html">Apache Storm 1.2.4 Released</a></li>
                    		
                      		<li><a href="/2021/09/27/storm230-released.html">Apache Storm 2.3.0 Released</a></li>
                    		
                      		<li><a href="/2020/06/30/storm220-released.html">Apache Storm 2.2.0 Released</a></li>
                    		
                      		<li><a href="/2019/10/31/storm210-released.html">Apache Storm 2.1.0 Released</a></li>
                    		
                      		<li><a href="/2019/07/18/storm123-released.html">Apache Storm 1.2.3 Released</a></li>
                    		
                      		<li><a href="/2019/05/30/storm200-released.html">Apache Storm 2.0.0 Released</a></li>
                    		
                      		<li><a href="/2018/06/04/storm122-released.html">Apache Storm 1.2.2 Released</a></li>
                    		
                      		<li><a href="/2018/06/04/storm113-released.html">Apache Storm 1.1.3 Released</a></li>
                    		
                      		<li><a href="/2018/02/19/storm121-released.html">Apache Storm 1.2.1 Released</a></li>
                    		
                      		<li><a href="/2018/02/15/storm120-released.html">Apache Storm 1.2.0 Released</a></li>
                    		
                      		<li><a href="/2018/02/15/storm112-released.html">Apache Storm 1.1.2 Released</a></li>
                    		
                      		<li><a href="/2018/02/14/storm106-released.html">Apache Storm 1.0.6 Released</a></li>
                    		
                      		<li><a href="/2017/09/15/storm105-released.html">Apache Storm 1.0.5 Released</a></li>
                    		
                      		<li><a href="/2017/08/01/storm111-released.html">Apache Storm 1.1.1 Released</a></li>
                    		
                      		<li><a href="/2017/07/28/storm104-released.html">Apache Storm 1.0.4 Released</a></li>
                    		
                      		<li><a href="/2017/03/29/storm110-released.html">Apache Storm 1.1.0 released</a></li>
                    		
                      		<li><a href="/2017/02/14/storm103-released.html">Apache Storm 1.0.3 Released</a></li>
                    		
                      		<li><a href="/2016/09/14/storm0102-released.html">Apache Storm 0.10.2 Released</a></li>
                    		
                      		<li><a href="/2016/09/07/storm097-released.html">Apache Storm 0.9.7 Released</a></li>
                    		
                      		<li><a href="/2016/08/10/storm102-released.html">Apache Storm 1.0.2 Released</a></li>
                    		
                      		<li><a href="/2016/05/06/storm101-released.html">Apache Storm 1.0.1 Released</a></li>
                    		
                      		<li><a href="/2016/05/05/storm0101-released.html">Apache Storm 0.10.1 Released</a></li>
                    		
                      		<li><a href="/2016/04/12/storm100-released.html">Apache Storm 1.0.0 released</a></li>
                    		
                      		<li><a href="/2015/11/05/storm096-released.html">Apache Storm 0.9.6 released</a></li>
                    		
                      		<li><a href="/2015/11/05/storm0100-released.html">Apache Storm 0.10.0 released</a></li>
                    		
                      		<li><a href="/2015/06/15/storm0100-beta-released.html">Apache Storm 0.10.0 Beta Released</a></li>
                    		
                      		<li><a href="/2015/06/04/storm095-released.html">Apache Storm 0.9.5 released</a></li>
                    		
                      		<li><a href="/2015/03/25/storm094-released.html">Apache Storm 0.9.4 released</a></li>
                    		
                      		<li><a href="/2014/11/25/storm093-released.html">Apache Storm 0.9.3 released</a></li>
                    		
                      		<li><a href="/2014/10/20/storm093-release-candidate.html">Apache Storm 0.9.3 release candidate 1 available</a></li>
                    		
                      		<li><a href="/2014/06/25/storm092-released.html">Apache Storm 0.9.2 released</a></li>
                    		
                      		<li><a href="/2014/06/17/contest-results.html">Apache Storm Logo Contest Results</a></li>
                    		
                      		<li><a href="/2014/05/27/round1-results.html">Logo Contest - Round 1 Results</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee3.html">Logo Entry No. 11 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee2.html">Logo Entry No. 10 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/29/logo-jlee1.html">Logo Entry No. 9 - Jennifer Lee</a></li>
                    		
                      		<li><a href="/2014/04/27/logo-sasili.html">Logo Entry No. 8 - Stefano Asili</a></li>
                    		
                      		<li><a href="/2014/04/27/logo-cboustead.html">Logo Entry No. 7 - Calum Boustead</a></li>
                    		
                      		<li><a href="/2014/04/23/logo-abartos.html">Logo Entry No. 6 - Alec Bartos</a></li>
                    		
                      		<li><a href="/2014/04/22/logo-zsayari.html">Logo Entry No. 5 - Ziba Sayari</a></li>
                    		
                      		<li><a href="/2014/04/21/logo-rmarshall.html">Logo Entry No. 4 - Richard Brownlie-Marshall</a></li>
                    		
                      		<li><a href="/2014/04/19/logo-ssuleman.html">Logo Entry No. 3- Shaan Shiv Suleman</a></li>
                    		
                      		<li><a href="/2014/04/17/logo-squinones.html">Logo Entry No. 2 - Samuel Quiñones</a></li>
                    		
                      		<li><a href="/2014/04/17/logo-pforrest.html">Logo Entry No. 1 - Patricia Forrest</a></li>
                    		
                      		<li><a href="/2014/04/10/storm-logo-contest.html">Apache Storm Logo Contest</a></li>
                    		
                      		<li><a href="/2013/12/08/storm090-released.html">Apache Storm 0.9.0 Released</a></li>
                    		
                      		<li><a href="/2013/01/11/storm082-released.html">Apache Storm 0.8.2 released</a></li>
                    		
                      		<li><a href="/2012/09/06/storm081-released.html">Apache Storm 0.8.1 released</a></li>
                    		
                      		<li><a href="/2012/08/02/storm080-released.html">Apache Storm 0.8.0 and Trident released</a></li>
                    		
                        </ul>
                    </div>
                    <div class="col-md-9" id="news-content">
                            <h1 class="page-title">
                               Apache Storm 0.9.2 released
                            </h1>
                                
                            <div class="row" style="margin: -15px;">
                                <div class="col-md-12">
                                    <p class="text-muted credit pull-left">Posted on Jun 25, 2014 by P. Taylor Goetz</p>
                                    <div class="pull-right">
                                        <a 
                                                href="https://twitter.com/share" 
                                                class="twitter-share-button"
                                                data-count=none
                                        >Tweet</a>
                                        <script> !function(d,s,id){
                                                var js,
                                                fjs=d.getElementsByTagName(s)[0],
                                                p=/^http:/.test(d.location)?'http':'https';
                                                if(!d.getElementById(id)){
                                                    js=d.createElement(s);
                                                    js.id=id;
                                                    js.src=p+'://platform.twitter.com/widgets.js';
                                                    fjs.parentNode.insertBefore(js,fjs);
                                                }
                                            }(document, 'script', 'twitter-wjs');
                                        </script>
                                    </div>
                                </div>
                            </div>
                        <div>
                	        <p>We are pleased to announce that Apache Storm 0.9.2-incubating has been released and is available from <a href="/downloads.html">the downloads page</a>. This release includes many important fixes and improvements.</p>

<h2 id="netty-transport-improvements">Netty Transport Improvements</h2>

<p>Apache Storm&#39;s Netty-based transport has been overhauled to significantly improve performance through better utilization of thread, CPU, and network resources, particularly in cases where message sizes are small. Apache Storm contributor Sean Zhong (<a href="https://github.com/clockfly">@clockfly</a>) deserves a great deal of credit not only for discovering, analyzing, documenting and fixing the root cause, but also for persevering through an extended review process and promptly addressing all concerns.</p>

<p>Those interested in the technical details and evolution of this patch can find out more in the <a href="https://issues.apache.org/jira/browse/STORM-297">JIRA ticket for STORM-297</a>.</p>

<p>Sean also discovered and fixed an <a href="https://issues.apache.org/jira/browse/STORM-342">elusive bug</a> in Apache Storm&#39;s usage of the Disruptor queue that could lead to out-of-order or lost messages. </p>

<p>Many thanks to Sean for contributing these important fixes.</p>

<h2 id="apache-storm-ui-improvements">Apache Storm UI Improvements</h2>

<p>This release also includes a number of improvements to the Apache Storm UI service. Contributor Sriharsha Chintalapani(<a href="https://github.com/harshach">@harshach</a>) added a REST API to the Apache Storm UI service to expose metrics and operations in JSON format, and updated the UI to use that API.</p>

<p>The new REST API will make it considerably easier for other services to consume availabe cluster and topology metrics for monitoring and visualization applications. Kyle Nusbaum (<a href="https://github.com/knusbaum">@knusbaum</a>) has already leveraged the REST API to create a topology visualization tool now included in Apache Storm UI and illustrated in the screenshot below.</p>

<p>&nbsp;</p>

<p><img src="/images/ui_topology_viz.png" alt="Apache Storm UI Topology Visualization"></p>

<p>&nbsp;</p>

<p>In the visualization, spout components are represented as blue, while bolts are colored between green and red depending on their associated capacity metric. The width of the lines between the components represent the flow of tuples relative to the other visible streams. </p>

<h2 id="kafka-spout">Kafka Spout</h2>

<p>This is the first Apache Storm release to include official support for consuming data from Kafka 0.8.x. In the past, development of Kafka spouts for Apache Storm had become somewhat fragmented and finding an implementation that worked with certain versions of Apache Storm and Kafka proved burdensome for some developers. This is no longer the case, as the <code>storm-kafka</code> module is now part of the Apache Storm project and associated artifacts are released to official channels (Maven Central) along with Apache Storm&#39;s other components.</p>

<p>Thanks are due to GitHub user <a href="">@wurstmeister</a> for picking up Nathan Marz&#39; original Kafka 0.7.x implementation, updating it to work with Kafka 0.8.x, and contributing that work back to the Apache Storm community.</p>

<p>The <code>storm-kafka</code> module can be found in the <code>/external/</code> directory of the source tree and binary distributions. The <code>external</code> area has been set up to contain projects that while not required by Apache Storm, are often used in conjunction with Apache Storm to integrate with some other technology. Such projects also come with a maintenance committment from at least one Apache Storm committer to ensure compatibility with Apache Storm&#39;s main codebase as it evolves.</p>

<p>The <code>storm-kafka</code> dependency is available now from Maven Central at the following coordinates:</p>
<div class="highlight"><pre><code class="language-" data-lang="">groupId: org.apache.storm
artifactId: storm-kafka
version: 0.9.2-incubating
</code></pre></div>
<p>Users, and Scala developers in particular, should note that the Kafka dependency is listed as <code>provided</code>. This allows users to choose a specific Scala version as described in the <a href="https://github.com/apache/incubator-storm/tree/v0.9.2-incubating/external/storm-kafka">project README</a>.</p>

<h2 id="apache-storm-starter-and-examples">Apache Storm Starter and Examples</h2>

<p>Similar to the <code>external</code> section of the codebase, we have also added an <code>examples</code> directory and pulled in the <code>storm-starter</code> project to ensure it will be maintained in lock-step with Apache Storm&#39;s main codebase.</p>

<p>Thank you to Apache Storm committer Michael G. Noll for his continued work in maintaining and improving the <code>storm-starter</code> project.</p>

<h2 id="plugable-serialization-for-multilang">Plugable Serialization for Multilang</h2>

<p>In previous versions of Apache Storm, serialization of data to and from multilang components was limited to JSON, imposing somewhat of performance penalty. Thanks to a contribution from John Gilmore (<a href="https://github.com/jsgilmore">@jsgilmore</a>) the serialization mechanism is now plugable and enables the use of more performant serialization frameworks like protocol buffers in addition to JSON.</p>

<h2 id="thanks">Thanks</h2>

<p>Special thanks are due to all those who have contributed to Apache Storm -- whether through direct code contributions, documentation, bug reports, or helping other users on the mailing lists. Your efforts are much appreciated.</p>

<h2 id="changelog">Changelog</h2>

<ul>
<li>STORM-352: [storm-kafka] PartitionManager does not save offsets to ZooKeeper</li>
<li>STORM-66: send taskid on initial handshake</li>
<li>STORM-342: Contention in Disruptor Queue which may cause out of order or lost messages</li>
<li>STORM-338: Move towards idiomatic Clojure style </li>
<li>STORM-335: add drpc test for removing timed out requests from queue</li>
<li>STORM-69: Storm UI Visualizations for Topologies</li>
<li>STORM-297: Performance scaling with CPU</li>
<li>STORM-244: DRPC timeout can return null instead of throwing an exception</li>
<li>STORM-63: remove timeout drpc request from its function&#39;s request queue</li>
<li>STORM-313: Remove log-level-page from logviewer</li>
<li>STORM-205: Add REST API To Storm UI</li>
<li>STORM-326: tasks send duplicate metrics</li>
<li>STORM-331: Update the Kafka dependency of storm-kafka to 0.8.1.1</li>
<li>STORM-308: Add support for config_value to {supervisor,nimbus,ui,drpc,logviewer} childopts</li>
<li>STORM-309: storm-starter Readme: windows documentation update</li>
<li>STORM-318: update storm-kafka to use apache curator-2.4.0</li>
<li>STORM-303: storm-kafka reliability improvements</li>
<li>STORM-233: Removed inline heartbeat to nimbus to avoid workers being killed when under heavy ZK load</li>
<li>STORM-267: fix package name of LoggingMetricsConsumer in storm.yaml.example</li>
<li>STORM-265: upgrade to clojure 1.5.1</li>
<li>STORM-232: ship JNI dependencies with the topology jar</li>
<li>STORM-295: Add storm configuration to define JAVA_HOME</li>
<li>STORM-138: Pluggable serialization for multilang</li>
<li>STORM-264: Removes references to the deprecated topology.optimize</li>
<li>STORM-245: implement Stream.localOrShuffle() for trident</li>
<li>STORM-317: Add SECURITY.md to release binaries</li>
<li>STORM-310: Change Twitter authentication</li>
<li>STORM-305: Create developer documentation</li>
<li>STORM-280: storm unit tests are failing on windows</li>
<li>STORM-298: Logback file does not include full path for metrics appender fileNamePattern</li>
<li>STORM-316: added validation to registermetrics to have timebucketSizeInSecs &gt;= 1</li>
<li>STORM-315: Added progress bar when submitting topology</li>
<li>STORM-214: Windows: storm.cmd does not properly handle multiple -c arguments</li>
<li>STORM-306: Add security documentation</li>
<li>STORM-302: Fix Indentation for pom.xml in storm-dist</li>
<li>STORM-235: Registering a null metric should blow up early</li>
<li>STORM-113: making thrift usage thread safe for local cluster</li>
<li>STORM-223: use safe parsing for reading YAML</li>
<li>STORM-238: LICENSE and NOTICE files are duplicated in storm-core jar</li>
<li>STORM-276: Add support for logviewer in storm.cmd.</li>
<li>STORM-286: Use URLEncoder#encode with the encoding specified.</li>
<li>STORM-296: Storm kafka unit tests are failing on windows</li>
<li>STORM-291: upgrade http-client to 4.3.3</li>
<li>STORM-252: Upgrade curator to latest version</li>
<li>STORM-294: Commas not escaped in command line</li>
<li>STORM-287: Fix the positioning of documentation strings in clojure code</li>
<li>STORM-290: Fix a log binding conflict caused by curator dependencies</li>
<li>STORM-289: Fix Trident DRPC memory leak</li>
<li>STORM-173: Treat command line &quot;-c&quot; option number config values as such</li>
<li>STORM-194: Support list of strings in *.worker.childopts, handle spaces</li>
<li>STORM-288: Fixes version spelling in pom.xml</li>
<li>STORM-208: Add storm-kafka as an external module</li>
<li>STORM-285: Fix storm-core shade plugin config</li>
<li>STORM-12: reduce thread usage of netty transport</li>
<li>STORM-281: fix and issue with config parsing that could lead to leaking file descriptors</li>
<li>STORM-196: When JVM_OPTS are set, storm jar fails to detect storm.jar from environment</li>
<li>STORM-260: Fix a potential race condition with simulated time in Storm&#39;s unit tests</li>
<li>STORM-258: Update commons-io version to 2.4</li>
<li>STORM-270: don&#39;t package .clj files in release jars.</li>
<li>STORM-273: Error while running storm topologies on Windows using &quot;storm jar&quot;</li>
<li>STROM-247: Replace links to github resources in storm script</li>
<li>STORM-263: Update Kryo version to 2.21+</li>
<li>STORM-187: Fix Netty error &quot;java.lang.IllegalArgumentException: timeout value is negative&quot;</li>
<li>STORM-186: fix float secs to millis long convertion</li>
<li>STORM-70: Upgrade to ZK-3.4.5 and curator-1.3.3</li>
<li>STORM-146: Unit test regression when storm is compiled with 3.4.5 zookeeper</li>
</ul>

                	    </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <footer>
    <div class="container-fluid">
        <div class="row">
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>Meetups</h5>
                    <ul class="latest-news">
                        
                        <li><a href="http://www.meetup.com/Apache-Storm-Apache-Kafka/">Apache Storm & Apache Kafka</a> <span class="small">(Sunnyvale, CA)</span></li>
                        
                        <li><a href="http://www.meetup.com/Apache-Storm-Kafka-Users/">Apache Storm & Kafka Users</a> <span class="small">(Seattle, WA)</span></li>
                        
                        <li><a href="http://www.meetup.com/New-York-City-Storm-User-Group/">NYC Storm User Group</a> <span class="small">(New York, NY)</span></li>
                        
                        <li><a href="http://www.meetup.com/Bay-Area-Stream-Processing">Bay Area Stream Processing</a> <span class="small">(Emeryville, CA)</span></li>
                        
                        <li><a href="http://www.meetup.com/Boston-Storm-Users/">Boston Realtime Data</a> <span class="small">(Boston, MA)</span></li>
                        
                        <li><a href="http://www.meetup.com/storm-london">London Storm User Group</a> <span class="small">(London, UK)</span></li>
                        
                        <!-- <li><a href="http://www.meetup.com/Apache-Storm-Kafka-Users/">Seatle, WA</a> <span class="small">(27 Jun 2015)</span></li> -->
                    </ul>
                </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>About Apache Storm</h5>
                    <p>Apache Storm integrates with any queueing system and any database system. Apache Storm's spout abstraction makes it easy to integrate a new queuing system. Likewise, integrating Apache Storm with database systems is easy.</p>
               </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>First Look</h5>
                    <ul class="footer-list">
                        <li><a href="/releases/current/Rationale.html">Rationale</a></li>
                        <li><a href="/releases/current/Tutorial.html">Tutorial</a></li>
                        <li><a href="/releases/current/Setting-up-development-environment.html">Setting up development environment</a></li>
                        <li><a href="/releases/current/Creating-a-new-Storm-project.html">Creating a new Apache Storm project</a></li>
                    </ul>
                </div>
            </div>
            <div class="col-md-3">
                <div class="footer-widget">
                    <h5>Documentation</h5>
                    <ul class="footer-list">
                        <li><a href="/releases/current/index.html">Index</a></li>
                        <li><a href="/releases/current/javadocs/index.html">Javadoc</a></li>
                        <li><a href="/releases/current/FAQ.html">FAQ</a></li>
                    </ul>
                </div>
            </div>
        </div>
        <hr/>
        <div class="row">   
            <div class="col-md-12">
                <p align="center">Copyright © 2021 <a href="http://www.apache.org">Apache Software Foundation</a>. All Rights Reserved. 
                    <br>Apache Storm, Apache, the Apache feather logo, and the Apache Storm project logos are trademarks of The Apache Software Foundation. 
                    <br>All other marks mentioned may be trademarks or registered trademarks of their respective owners.</p>
            </div>
        </div>
    </div>
</footer>
<!--Footer End-->
<!-- Scroll to top -->
<span class="totop"><a href="#"><i class="fa fa-angle-up"></i></a></span> 

    </body>

</html>

