---
layout: post
title: The Apache Software Foundation Announces Apache® SkyWalking™ as a Top-Level
  Project
date: '2019-04-24T10:00:33+00:00'
categories: foundation
---
<div><strong><em>Open Source Application Performance Monitor (APM) tool in use at Alibaba, China Eastern Airlines, Huawei, and WeBank, among others.</em></strong></div> 
  <div><strong><br /></strong></div> 
  <div><strong>Wakefield, MA —24 April 2019—</strong> The Apache Software Foundation (ASF), the all-volunteer developers, stewards, and incubators of more than 350 Open Source projects and initiatives, announced today Apache<sup>®</sup> SkyWalking™ as a Top-Level Project (TLP).</div> 
  <div><br /></div> 
  <div>Apache SkyWalking is an application performance monitor (APM) tool that provides an automatic, highly efficient way to instrument microservices, cloud native, and container-based applications. The project was originally developed in 2015, and entered the Apache Incubator in December 2017.</div> 
  <div> 
    <p>&quot;This is a special day for the SkyWalking project and its community. We thank our mentors, contributors, and the Apache Incubator for helping us achieve this goal,&quot; said Sheng Wu, Vice President of Apache SkyWalking. &quot;The original agenda behind SkyWalking was to help newcomers understand what is distributed tracing, and the community has grown bigger and stronger since we entered the Apache Incubator. Through The Apache Way, SkyWalking has a very active and diverse community, is used by over 70 companies, and has over 100 source contributors from dozens of different organizations.&quot;</p> 
    <p>Apache SkyWalking provides tracing, service mesh telemetry analysis, metric aggregation and visualization for the distributed system. The project landscape has expanded from a pure tracing system, to an observability analysis platform, and application performance management/monitoring system. Features include:</p> 
  </div> 
  <div> 
    <ul> 
      <li>Distributed tracing-based APM: 100% traces collected with low payload for original system;</li> 
      <li>Cloud-native friendly: observe distributed system powered by service mesh, Istio and Envoy;</li> 
      <li>Automated source code change: multiple language agents provided, especially with auto instrumentation supported, in Java, .NET and Nodejs;</li> 
      <li>Easy to operate: doesn’t require Big Data in monitoring large scale distributed system; and</li> 
      <li>Advanced visualization: used in traces, metrics and topology map.</li> 
    </ul> 
  </div> 
  <div> </div> 
  <div> 
    <p>Apache SkyWalking is in use at dozens of organizations that include 5i5j Group, Alibaba, autohome.com, China Eastern Airlines, China Merchants Bank, Daocloud, dangdang.com, guazi.com, Huawei, ke.com, iFLYTEK, primeton.com, Sinolink Securities, tetrate.io, tuhu.cn, tuya.com, WeBank, Yonghui Superstores, youzan.com, and more.</p> 
    <p>&quot;Instrumentation is unquestionably the most time-consuming part of establishing a distributed tracing solution into an existing platform. I had the chance to code with some of the SkyWalking community earlier on and could see the quality being invested back then,&quot; said Mick Semb Wever, ASF Member and Apache SkyWalking Incubating Mentor. &quot;When they were looking for mentors and a champion to help them create a proposal to become an Apache project, I was excited at the opportunity to help bring the project to the Apache Incubator, and was pleasantly surprised to see how prepared, and ASF-like, the SkyWalking community and project had already become. As was the case with Apache Kylin, SkyWalking has not only been a model project during the incubation process, they have also become ambassadors on open development The Apache Way to the greater Open Source community in China. Congratulations on graduating as an Apache Top-Level Project.&quot;</p> 
  </div> 
  <div> </div> 
  <div>&quot;SkyWalking is one of the only Open Source tracing systems where usability and user interface have been a focus, something missing in most Open Source projects,&quot; said Jonah Kowall, CTO at Kentik, and former VP Research at Gartner. &quot;Making tracing and APM more easily used by developers and operations team is a key goal which makes Apache Skywalking a project to watch.&quot;</div> 
  <div><br /></div> 
  <div>&quot;Apache SkyWalking has done a lot of work in spreading modern cloud native observability in China and across the world,&quot; said Chris Aniczszyk, CTO and COO of the Cloud Native Computing Foundation. &quot;We are happy to see Apache SkyWalking become a TLP and look forward to their community growing and collaborating with CNCF projects like Kubernetes, Envoy, Jaeger and more.&quot;</div> 
  <div><br /></div> 
  <div>&quot;I hear regularly from users that observability is the most important feature they're getting out of their service mesh,&quot; said Zack Butcher, Core Contributor to Istio. &quot;By integrating Apache SkyWalking with Istio, the SkyWalking team has brought their incredible tools for deeply understanding system behavior to the mesh. We've already seen great results, and I can't wait to see what further insights users unlock using Apache SkyWalking together with Istio to observe and manage their deployments.&quot;</div> 
  <div><br /></div> 
  <div>&quot;At WeBank, we use different banking architectures, from distributed architecture to Open Source technologies. We’ve built a messaging bus called WeMQ based on Apache RocketMQ that fully utilizes the benefits of messaging by implementing various messaging techniques in different scenarios, such as message exchanges, pub/sub and request/reply models,&quot; said Eason Chen, WeBank Tech Specialist, and Apache RocketMQ Contributor. &quot;However, after adding different messaging services that are critical to our business, we realized there is a need for a universal visual traceable system for the distributed message to help us to diagnosis problem of applications. We believe Apache SkyWalking can address our current challenges, and we look forward to contributing to its efforts.&quot;</div> 
  <div><br /></div> 
  <div>&quot;I am very glad to see SkyWalking has been promoted as Apache Top-Level Project,&quot; said Lie Mao, Architect at China Eastern Airlines IT Solution Department. &quot;Apache SkyWalking is integrated into the China Eastern Airlines microservice architecture support platform. SkyWalking provides practical features and visualization capabilities about topology map and distributed tracing, to help us understand the distributed system. I hope the Open Source community can contribute more plugins to Apache SkyWalking to enhance its role in the multi-language hybrid architecture.&quot;</div> 
  <div><br /></div> 
  <div>&quot;I found SkyWalking in 2017. In two years, it has grown very fast, and the community is very active,&quot; said DongXue Si, Senior Software Engineer at CloudWise Inc. &quot;The project is adopted by many companies, and is attracting a lot of developers. Apache SkyWalking makes application performance monitoring easier and more convenient. I believe it will be better and better powered by its diversity community: Bless it.&quot;</div> 
  <div><br /></div> 
  <div>&quot;As early adopters of SkyWalking, we are very glad to see it graduate as an Apache Top-Level Project,&quot; said Liang Zhang, Architect at JD.com, Podling Project Management Committee member of Apache ShardingSphere (incubating), and former Architect at dangdang.com. &quot;Dangdang.com adopted SkyWalking much earlier before it joined the Apache Incubator: we have witnessed its development, new features, and community growth. It is a very good example for Apache ShardingSphere (incubating). I look forward to our projects cooperating on observability in databases, and building a better Open Source ecosystem together.&quot;</div> 
  <div><br /></div> 
  <div>&quot;Congratulations to SkyWalking for becoming an Apache Top Level project,&quot; said Yuqi Zhou, Middleware Development Manager at Sinolink Securities Co. &quot;Apache SkyWalking’s elegant design and good performance solves the our tracing and monitoring needs. Thanks to the Open Source community for bringing us such an awesome project: I wish it continued success.&quot;</div> 
  <div><br /></div> 
  <div>&quot;In helping enterprise customers transform their business application from traditional architecture to a Microservices architecture, one of the most important aspects of the microservices governance platform is its observability to obtain invocation relationships between components, as well as inside service itself, and to generate statistics based on these data, including SLA of services provided to the outside world,&quot; said Grissom Wang, Chief Architect at DaoCloud. &quot;We surveyed a number of similar Open Source technologies and eventually chose Apache SkyWalking as one of the core components of DaoCloud Microservices platform because of its openness, extendibility, high performance, excellent code quality, active community, and forward-looking integration with Istio.&quot;</div> 
  <div><br /></div> 
  <div>&quot;Congrats SkyWalking being an Apache TLP,&quot; said Niangang Xu, co-founder of Yonghui Cloud Computing. &quot;Apache SkyWalking helps us to improve the design of microservice, and has been enabling us to manage and observe a lot of distributed systems at scale!&quot;</div> 
  <div><br /></div> 
  <div>&quot;SkyWalking is on its way to becoming a world wide Open Source project,&quot; added Wu. &quot;We welcome everyone to participate on our mailing lists, GitHub, and Slack channels, and to learn more through our events, presentations, Website, and documents.&quot;</div> 
  <div><br /></div> 
  <div>Catch Apache SkyWalking in action at SkyWalking DevCon (Shanghai; 11 May 2019), GIAC (Shenzhen; 21-23 June 2019), KubeCon + CloudNativeCon China (Shanghai; 25-26 June 2019), ApacheCon North America&nbsp; (Las Vegas; 9-12 September 2019), and DevOps Stage (Kiev; 18-19 October 2019).</div> 
  <div><br /></div> 
  <div><strong>Availability and Oversight</strong></div> 
  <div>Apache SkyWalking software is released under the Apache License v2.0 and is overseen by a self-selected team of active contributors to the project. A Project Management Committee (PMC) guides the Project's day-to-day operations, including community development and product releases. For downloads, documentation, and ways to become involved with Apache SkyWalking, visit <a href="http://skywalking.apache.org/">http://skywalking.apache.org/</a> and <a href="https://twitter.com/ASFSkyWalking">https://twitter.com/ASFSkyWalking</a></div> 
  <div><br /></div> 
  <div><strong>About the Apache Incubator</strong></div> 
  <div>The Apache Incubator is the entry path for projects and codebases wishing to become part of the efforts at The Apache Software Foundation. All code donations from external organizations and existing external projects wishing to join the ASF enter through the Incubator to: 1) ensure all donations are in accordance with the ASF legal standards; and 2) develop new communities that adhere to our guiding principles. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF. For more information, visit <a href="http://incubator.apache.org/">http://incubator.apache.org/</a></div> 
  <div><br /></div> 
  <div><strong>About The Apache Software Foundation (ASF)</strong></div> 
  <div>Established in 1999, the all-volunteer Foundation oversees more than 350 leading Open Source projects that provide $20B+ worth of Apache Open Source software to the public at 100% no cost. Through the ASF's merit-based process known as &quot;The Apache Way,&quot; more than 730 individual Members and 7,000 Committers across six continents successfully collaborate to develop freely available enterprise-grade software, benefiting billions of users worldwide: thousands of software solutions are distributed under the Apache License; and the community actively participates in ASF mailing lists, mentoring initiatives, and ApacheCon, the Foundation's official user conference, trainings, and expo. The ASF is a US 501(c)(3) charitable organization, funded by individual donations and corporate sponsors including Aetna, Alibaba Cloud Computing, Anonymous, ARM, Baidu, Bloomberg, Budget Direct, Capital One, Cerner, Cloudera, Comcast, Facebook, Google, Handshake, Hortonworks, Huawei, IBM, Indeed, Inspur, Leaseweb, Microsoft, ODPi, Pineapple Fund, Pivotal, Private Internet Access, Red Hat, Target, Tencent, Union Investment, Workday, and Verizon Media. For more information, visit <a href="http://apache.org/">http://apache.org/</a> and <a href="https://twitter.com/TheASF">https://twitter.com/TheASF</a></div> 
  <div><br /></div> 
  <div>© The Apache Software Foundation. &quot;Apache&quot;, &quot;SkyWalking&quot;, &quot;Apache SkyWalking&quot;, &quot;Kylin&quot;, &quot;Apache Kylin&quot;, &quot;RocketMQ&quot;, &quot;Apache RocketMQ&quot;, and &quot;ApacheCon&quot; are registered trademarks or trademarks of the Apache Software Foundation in the United States and/or other countries. All other brands and trademarks are the property of their respective owners.<br /><br /></div> 
  <div> </div> 
  <div># # #</div>
