From commits-return-479-archive-asf-public=cust-asf.ponee.io@zipkin.apache.org Sun Apr 21 21:02:27 2019 Return-Path: X-Original-To: archive-asf-public@cust-asf.ponee.io Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [207.244.88.153]) by mx-eu-01.ponee.io (Postfix) with SMTP id 4A888180658 for ; Sun, 21 Apr 2019 23:02:26 +0200 (CEST) Received: (qmail 20227 invoked by uid 500); 21 Apr 2019 21:02:25 -0000 Mailing-List: contact commits-help@zipkin.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@zipkin.apache.org Delivered-To: mailing list commits@zipkin.apache.org Received: (qmail 20040 invoked by uid 99); 21 Apr 2019 21:02:25 -0000 Received: from ec2-52-202-80-70.compute-1.amazonaws.com (HELO gitbox.apache.org) (52.202.80.70) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 21 Apr 2019 21:02:25 +0000 Received: by gitbox.apache.org (ASF Mail Server at gitbox.apache.org, from userid 33) id EAED887A39; Sun, 21 Apr 2019 21:02:24 +0000 (UTC) Date: Sun, 21 Apr 2019 21:02:37 +0000 To: "commits@zipkin.apache.org" Subject: [incubator-zipkin-website] 13/16: Temporary duct-tape to revive https://zipkin.io/zipkin-api/ MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit From: abesto@apache.org In-Reply-To: <155588054438.2698.15509798206001353269@gitbox.apache.org> References: <155588054438.2698.15509798206001353269@gitbox.apache.org> X-Git-Host: gitbox.apache.org X-Git-Repo: incubator-zipkin-website X-Git-Refname: refs/heads/sync-from-githubio X-Git-Reftype: branch X-Git-Rev: 956ce8c0e5a69d71230e7eff5a84ba2668eec9f8 X-Git-NotificationType: diff X-Git-Multimail-Version: 1.5.dev Auto-Submitted: auto-generated Message-Id: <20190421210224.EAED887A39@gitbox.apache.org> This is an automated email from the ASF dual-hosted git repository. abesto pushed a commit to branch sync-from-githubio in repository https://gitbox.apache.org/repos/asf/incubator-zipkin-website.git commit 956ce8c0e5a69d71230e7eff5a84ba2668eec9f8 Author: Zoltan Nagy AuthorDate: Sun Apr 21 21:24:45 2019 +0100 Temporary duct-tape to revive https://zipkin.io/zipkin-api/ See https://github.com/apache/incubator-zipkin-api/issues/62 --- public/zipkin-api/404.html | 137 ++++++ public/zipkin-api/CONTRIBUTING.md | 9 + public/zipkin-api/LICENSE | 201 ++++++++ public/zipkin-api/README.md | 14 + public/zipkin-api/config.json | 3 + public/zipkin-api/favicon-16x16.png | Bin 0 -> 445 bytes public/zipkin-api/favicon-32x32.png | Bin 0 -> 1141 bytes public/zipkin-api/index.html | 95 ++++ public/zipkin-api/package.json | 27 ++ public/zipkin-api/swagger-ui-bundle.js | 81 ++++ public/zipkin-api/swagger-ui-bundle.js.map | 1 + public/zipkin-api/swagger-ui-standalone-preset.js | 13 + .../zipkin-api/swagger-ui-standalone-preset.js.map | 1 + public/zipkin-api/swagger-ui.css | 2 + public/zipkin-api/swagger-ui.css.map | 1 + public/zipkin-api/swagger-ui.js | 8 + public/zipkin-api/swagger-ui.js.map | 1 + public/zipkin-api/thrift/zipkinCore.thrift | 507 +++++++++++++++++++++ public/zipkin-api/thrift/zipkinDependencies.thrift | 38 ++ public/zipkin-api/validate.js | 31 ++ public/zipkin-api/zipkin-api.yaml | 423 +++++++++++++++++ public/zipkin-api/zipkin.proto | 213 +++++++++ public/zipkin-api/zipkin2-api.yaml | 464 +++++++++++++++++++ 23 files changed, 2270 insertions(+) diff --git a/public/zipkin-api/404.html b/public/zipkin-api/404.html new file mode 100644 index 0000000..2a43bd3 --- /dev/null +++ b/public/zipkin-api/404.html @@ -0,0 +1,137 @@ +Page Not Found :(

Not found :(

Sorry, but the page you were trying to view does not exist.

It looks like this was the result of either:

  • a mistyped address
  • an out-of-date link
\ No newline at end of file diff --git a/public/zipkin-api/CONTRIBUTING.md b/public/zipkin-api/CONTRIBUTING.md new file mode 100644 index 0000000..c947d23 --- /dev/null +++ b/public/zipkin-api/CONTRIBUTING.md @@ -0,0 +1,9 @@ +# Contributing to Zipkin + +If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request (on a branch other than `master` or `gh-pages`). + +## License + +By contributing your code, you agree to license your contribution under the terms of the APLv2: https://github.com/openzipkin/zipkin/blob/master/LICENSE + +All files are released with the Apache 2.0 license. diff --git a/public/zipkin-api/LICENSE b/public/zipkin-api/LICENSE new file mode 100644 index 0000000..8dada3e --- /dev/null +++ b/public/zipkin-api/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/public/zipkin-api/README.md b/public/zipkin-api/README.md new file mode 100644 index 0000000..617a077 --- /dev/null +++ b/public/zipkin-api/README.md @@ -0,0 +1,14 @@ +# Zipkin API + +[![Build Status](https://travis-ci.org/openzipkin/zipkin-api.svg?branch=master)](https://travis-ci.org/openzipkin/zipkin-api) + +This repo includes an [OpenAPI Spec](./zipkin-api.yaml) and [Protocol Buffers interchange format](./zipkin.proto). + +## Language independent interchange format for Zipkin transports +* [Protocol Buffers v3](./zipkin.proto) - Requires Zipkin 2.8+ or similar to parse it. + +## OpenApi (Http endpoint of the zipkin server) +* [/api/v1](./zipkin-api.yaml) - Still supported on zipkin-server +* [/api/v2](./zipkin2-api.yaml) - Most recent and published [here](http://zipkin.io/zipkin-api/#/) + +Take a look at the [example repository](https://github.com/openzipkin/zipkin-api-example) for how to use this. diff --git a/public/zipkin-api/config.json b/public/zipkin-api/config.json new file mode 100644 index 0000000..425cf2f --- /dev/null +++ b/public/zipkin-api/config.json @@ -0,0 +1,3 @@ +{ + "loadSwaggerFrom": "./zipkin2-api.yaml" +} diff --git a/public/zipkin-api/favicon-16x16.png b/public/zipkin-api/favicon-16x16.png new file mode 100644 index 0000000..0f7e13b Binary files /dev/null and b/public/zipkin-api/favicon-16x16.png differ diff --git a/public/zipkin-api/favicon-32x32.png b/public/zipkin-api/favicon-32x32.png new file mode 100644 index 0000000..b0a3352 Binary files /dev/null and b/public/zipkin-api/favicon-32x32.png differ diff --git a/public/zipkin-api/index.html b/public/zipkin-api/index.html new file mode 100644 index 0000000..1ee425e --- /dev/null +++ b/public/zipkin-api/index.html @@ -0,0 +1,95 @@ + + + + + + Swagger UI + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + diff --git a/public/zipkin-api/package.json b/public/zipkin-api/package.json new file mode 100644 index 0000000..d31c803 --- /dev/null +++ b/public/zipkin-api/package.json @@ -0,0 +1,27 @@ +{ + "name": "zipkin-api", + "version": "0.0.0", + "description": "Zipkin API ", + "main": "validate.js", + "scripts": { + "test": "node validate.js" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/openzipkin/zipkin-api.git" + }, + "keywords": [ + "zipkin", + "api" + ], + "author": "", + "license": "ASL", + "bugs": { + "url": "https://github.com/openzipkin/zipkin-api/issues" + }, + "homepage": "https://github.com/openzipkin/zipkin-api#readme", + "devDependencies": { + "js-yaml": "^3.6.0", + "sway": "^1.0.0" + } +} diff --git a/public/zipkin-api/swagger-ui-bundle.js b/public/zipkin-api/swagger-ui-bundle.js new file mode 100644 index 0000000..df85dc8 --- /dev/null +++ b/public/zipkin-api/swagger-ui-bundle.js @@ -0,0 +1,81 @@ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.SwaggerUIBundle=t():e.SwaggerUIBundle=t()}(this,function(){return function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{c [...] +object-assign +(c) Sindre Sorhus +@license MIT +*/ +var i=Object.getOwnPropertySymbols,o=Object.prototype.hasOwnProperty,a=Object.prototype.propertyIsEnumerable;e.exports=function(){try{if(!Object.assign)return!1;var e=new String("abc");if(e[5]="de","5"===Object.getOwnPropertyNames(e)[0])return!1;for(var t={},n=0;n<10;n++)t["_"+String.fromCharCode(n)]=n;if("0123456789"!==Object.getOwnPropertyNames(t).map(function(e){return t[e]}).join(""))return!1;var r={};return"abcdefghijklmnopqrst".split("").forEach(function(e){r[e]=e}),"abcdefghijklmn [...] + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var Y=n(593),$=n(706),Z=n(364);t.Buffer=o,t.SlowBuffer=m,t.INSPECT_MAX_BYTES=50,o.TYPED_ARRAY_SUPPORT=void 0!==e.TYPED_ARRAY_SUPPORT?e.TYPED_ARRAY_SUPPORT:function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(e){return!1}}(),t.kMaxLength=r(),o.poolSize=8192,o._augment=function(e){return e.__proto__=o.prototype,e},o.from=function(e,t,n){return a( [...] + * @description Recursive object extending + * @author Viacheslav Lotsmanov + * @license MIT + * + * The MIT License (MIT) + * + * Copyright (c) 2013-2015 Viacheslav Lotsmanov + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of + * the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +function n(e){return e instanceof t||e instanceof Date||e instanceof RegExp}function r(e){if(e instanceof t){var n=new t(e.length);return e.copy(n),n}if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)return new RegExp(e);throw new Error("Unexpected situation")}function i(e){var t=[];return e.forEach(function(e,a){"object"==typeof e&&null!==e?Array.isArray(e)?t[a]=i(e):n(e)?t[a]=r(e):t[a]=o({},e):t[a]=e}),t}var o=e.exports=function(){if(arguments.length<1||"object"! [...] + * Checks if an event is supported in the current execution environment. + * + * NOTE: This will not work correctly for non-generic events such as `change`, + * `reset`, `load`, `error`, and `select`. + * + * Borrows from Modernizr. + * + * @param {string} eventNameSuffix Event name, e.g. "click". + * @param {?boolean} capture Check if the capture phase is supported. + * @return {boolean} True if the event is supported. + * @internal + * @license Modernizr 3.0.0pre (Custom Build) | MIT + */ +function r(e,t){if(!o.canUseDOM||t&&!("addEventListener"in document))return!1;var n="on"+e,r=n in document;if(!r){var a=document.createElement("div");a.setAttribute(n,"return;"),r="function"==typeof a[n]}return!r&&i&&"wheel"===e&&(r=document.implementation.hasFeature("Events.wheel","3.0")),r}var i,o=n(22);o.canUseDOM&&(i=document.implementation&&document.implementation.hasFeature&&!0!==document.implementation.hasFeature("","")),e.exports=r},function(e,t,n){"use strict";function r(e,t){va [...] + * Autolinker.js + * 0.15.3 + * + * Copyright(c) 2015 Gregory Jacobs + * MIT Licensed. http://www.opensource.org/licenses/mit-license.php + * + * https://github.com/gregjacobs/Autolinker.js + */ +var e=function(t){e.Util.assign(this,t)};return e.prototype={constructor:e,urls:!0,email:!0,twitter:!0,newWindow:!0,stripPrefix:!0,truncate:void 0,className:"",htmlParser:void 0,matchParser:void 0,tagBuilder:void 0,link:function(e){for(var t=this.getHtmlParser(),n=t.parse(e),r=0,i=[],o=0,a=n.length;o1&&n[1]||""}var n,r=t(/(ipod|iphone|ipad)/i).toLowerCase(),i=/like android/i.test(e),o=!i&&/android/i.test(e),s=/nexus\s*[0-6]\s*/i.test(e),u=!s&&/nexus\s*[0-9]+/i.test(e),c=/CrOS/.test(e),l=/silk/i.test(e),p=/sailfish/i.test(e),f=/tizen/i.test(e),h=/(web|hpw)os/i.test(e),d=/windows phone/i.test(e),m=(/SamsungBrowser/i.test(e),!d&&/windo [...] +if(String.fromCodePoint)e.exports=function(e){try{return String.fromCodePoint(e)}catch(e){if(e instanceof RangeError)return String.fromCharCode(65533);throw e}};else{var r=String.fromCharCode,i=Math.floor,o=function(){var e,t,n=[],o=-1,a=arguments.length;if(!a)return"";for(var s="";++o1114111||i(u)!==u)return String.fromCharCode(65533);u<=65535?n.push(u):(u-=65536,e=55296+(u>>10),t=u%1024+56320,n.push(e,t)),(o+1===a||n.length>16384) [...] + * https://github.com/Starcounter-Jack/JSON-Patch + * json-patch-duplex.js version: 1.1.10 + * (c) 2013 Joachim Wester + * MIT license + */ +var n;if(function(e){function t(e,n){switch(typeof e){case"undefined":case"boolean":case"string":case"number":return e===n;case"object":if(null===e)return null===n;if(S(e)){if(!S(n)||e.length!==n.length)return!1;for(var r=0,i=e.length;r + * + * Copyright (c) 2015, Jon Schlinkert. + * Licensed under the MIT License. + */ +function n(e){if("string"!=typeof e)throw new TypeError("expected a string.");return e=e.replace(/([A-Z])/g," $1"),1===e.length?e.toUpperCase():(e=e.replace(/^[\W_]+|[\W_]+$/g,"").toLowerCase(),e=e.charAt(0).toUpperCase()+e.slice(1),e.replace(/[\W_]+(\w|$)/g,function(e,t){return t.toUpperCase()}))}e.exports=n},function(e,t,n){"use strict";function r(e,t,n,r,i){}e.exports=r},function(e,t,n){"use strict";var r=n(26),i=n(7),o=n(403);e.exports=function(){function e(e,t,n,r,a,s){s!==o&&i(!1," [...] +String.prototype.repeat||function(){"use strict";var e=function(){try{var e={},t=Object.defineProperty,n=t(e,e,e)&&t}catch(e){}return n}(),t=function(e){if(null==this)throw TypeError();var t=String(this),n=e?Number(e):0;if(n!=n&&(n=0),n<0||n==1/0)throw RangeError();for(var r="";n;)n%2==1&&(r+=t),n>1&&(t+=t),n>>=1;return r};e?e(String.prototype,"repeat",{value:t,configurable:!0,writable:!0}):String.prototype.repeat=t}()},function(e,t,n){var r=n(69),i=n(39),o=r(i,"DataView");e.exports=o},f [...] +//# sourceMappingURL=swagger-ui-bundle.js.map \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui-bundle.js.map b/public/zipkin-api/swagger-ui-bundle.js.map new file mode 100644 index 0000000..4f3e8b1 --- /dev/null +++ b/public/zipkin-api/swagger-ui-bundle.js.map @@ -0,0 +1 @@ +{"version":3,"file":"swagger-ui-bundle.js","sources":["webpack:///swagger-ui-bundle.js"],"mappings":"AAAA;;;;;AAoyKA;;;;;;AAm/EA;;;;;;;;;;;;;;;;;;;;;;;;;;AAs6TA;;;;;;;;;;;;;;AAs8JA;;;;;;;;;AAogpBA;;;;;AAk1QA;AAm4DA;;;;;;AAo4YA;;;;;;AA8jaA;AAumvBA","sourceRoot":""} \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui-standalone-preset.js b/public/zipkin-api/swagger-ui-standalone-preset.js new file mode 100644 index 0000000..7604d76 --- /dev/null +++ b/public/zipkin-api/swagger-ui-standalone-preset.js @@ -0,0 +1,13 @@ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.SwaggerUIStandalonePreset=e():t.SwaggerUIStandalonePreset=e()}(this,function(){return function(t){function e(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return t[r].call(i.exports,i,i.exports,e),i.l=!0,i.exports}var n={};return e.m=t,e.c=n,e.i=function(t){return t},e.d=function(t,n,r){e.o(t,n)||Object.d [...] +object-assign +(c) Sindre Sorhus +@license MIT +*/ +var i=Object.getOwnPropertySymbols,s=Object.prototype.hasOwnProperty,o=Object.prototype.propertyIsEnumerable;t.exports=function(){try{if(!Object.assign)return!1;var t=new String("abc");if(t[5]="de","5"===Object.getOwnPropertyNames(t)[0])return!1;for(var e={},n=0;n<10;n++)e["_"+String.fromCharCode(n)]=n;if("0123456789"!==Object.getOwnPropertyNames(e).map(function(t){return e[t]}).join(""))return!1;var r={};return"abcdefghijklmnopqrst".split("").forEach(function(t){r[t]=t}),"abcdefghijklmn [...] + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var V=n(139),$=n(174),Z=n(175);e.Buffer=s,e.SlowBuffer=m,e.INSPECT_MAX_BYTES=50,s.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:function(){try{var t=new Uint8Array(1);return t.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===t.foo()&&"function"==typeof t.subarray&&0===t.subarray(1,1).byteLength}catch(t){return!1}}(),e.kMaxLength=r(),s.poolSize=8192,s._augment=function(t){return t.__proto__=s.prototype,t},s.from=function(t,e,n){return o( [...] +//# sourceMappingURL=swagger-ui-standalone-preset.js.map \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui-standalone-preset.js.map b/public/zipkin-api/swagger-ui-standalone-preset.js.map new file mode 100644 index 0000000..b31b700 --- /dev/null +++ b/public/zipkin-api/swagger-ui-standalone-preset.js.map @@ -0,0 +1 @@ +{"version":3,"file":"swagger-ui-standalone-preset.js","sources":["webpack:///swagger-ui-standalone-preset.js"],"mappings":"AAAA;;;;;AA21CA;;;;;;AAspFA","sourceRoot":""} \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui.css b/public/zipkin-api/swagger-ui.css new file mode 100644 index 0000000..a75d9db --- /dev/null +++ b/public/zipkin-api/swagger-ui.css @@ -0,0 +1,2 @@ +.swagger-ui{font-family:Open Sans,sans-serif;color:#3b4151}.swagger-ui .wrapper{width:100%;max-width:1460px;margin:0 auto;padding:0 20px}.swagger-ui .opblock-tag-section{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-orient:vertical;-webkit-box-direction:normal;-ms-flex-direction:column;flex-direction:column}.swagger-ui .opblock-tag{display:-webkit-box;display:-ms-flexbox;display:flex;-webkit-box-align:center;-ms-flex-align:center;align-items:center;padding:10px 20px 10 [...] +/*# sourceMappingURL=swagger-ui.css.map*/ \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui.css.map b/public/zipkin-api/swagger-ui.css.map new file mode 100644 index 0000000..dbf47ea --- /dev/null +++ b/public/zipkin-api/swagger-ui.css.map @@ -0,0 +1 @@ +{"version":3,"file":"swagger-ui.css","sources":[],"mappings":"","sourceRoot":""} \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui.js b/public/zipkin-api/swagger-ui.js new file mode 100644 index 0000000..2ac676c --- /dev/null +++ b/public/zipkin-api/swagger-ui.js @@ -0,0 +1,8 @@ +!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("react"),require("prop-types"),require("immutable"),require("react-immutable-proptypes"),require("reselect"),require("serialize-error"),require("deep-extend"),require("react-collapse"),require("swagger-client"),require("base64-js"),require("ieee754"),require("isarray"),require("js-yaml"),require("memoizee"),require("react-dom"),require("react-markdown"),require("react-redux"),require("react-remarkab [...] + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +var G=n(510),X=n(511),Z=n(512);t.Buffer=a,t.SlowBuffer=m,t.INSPECT_MAX_BYTES=50,a.TYPED_ARRAY_SUPPORT=void 0!==e.TYPED_ARRAY_SUPPORT?e.TYPED_ARRAY_SUPPORT:function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(e){return!1}}(),t.kMaxLength=r(),a.poolSize=8192,a._augment=function(e){return e.__proto__=a.prototype,e},a.from=function(e,t,n){return u( [...] +//# sourceMappingURL=swagger-ui.js.map \ No newline at end of file diff --git a/public/zipkin-api/swagger-ui.js.map b/public/zipkin-api/swagger-ui.js.map new file mode 100644 index 0000000..95e79fd --- /dev/null +++ b/public/zipkin-api/swagger-ui.js.map @@ -0,0 +1 @@ +{"version":3,"file":"swagger-ui.js","sources":["webpack:///swagger-ui.js"],"mappings":"AAAA;;;;;;AA0/cA","sourceRoot":""} \ No newline at end of file diff --git a/public/zipkin-api/thrift/zipkinCore.thrift b/public/zipkin-api/thrift/zipkinCore.thrift new file mode 100644 index 0000000..3db9a91 --- /dev/null +++ b/public/zipkin-api/thrift/zipkinCore.thrift @@ -0,0 +1,507 @@ +# Copyright 2012 Twitter Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +namespace java com.twitter.zipkin.thriftjava +#@namespace scala com.twitter.zipkin.thriftscala +namespace rb Zipkin + +#************** Annotation.value ************** +/** + * The client sent ("cs") a request to a server. There is only one send per + * span. For example, if there's a transport error, each attempt can be logged + * as a WIRE_SEND annotation. + * + * If chunking is involved, each chunk could be logged as a separate + * CLIENT_SEND_FRAGMENT in the same span. + * + * Annotation.host is not the server. It is the host which logged the send + * event, almost always the client. When logging CLIENT_SEND, instrumentation + * should also log the SERVER_ADDR. + */ +const string CLIENT_SEND = "cs" +/** + * The client received ("cr") a response from a server. There is only one + * receive per span. For example, if duplicate responses were received, each + * can be logged as a WIRE_RECV annotation. + * + * If chunking is involved, each chunk could be logged as a separate + * CLIENT_RECV_FRAGMENT in the same span. + * + * Annotation.host is not the server. It is the host which logged the receive + * event, almost always the client. The actual endpoint of the server is + * recorded separately as SERVER_ADDR when CLIENT_SEND is logged. + */ +const string CLIENT_RECV = "cr" +/** + * The server sent ("ss") a response to a client. There is only one response + * per span. If there's a transport error, each attempt can be logged as a + * WIRE_SEND annotation. + * + * Typically, a trace ends with a server send, so the last timestamp of a trace + * is often the timestamp of the root span's server send. + * + * If chunking is involved, each chunk could be logged as a separate + * SERVER_SEND_FRAGMENT in the same span. + * + * Annotation.host is not the client. It is the host which logged the send + * event, almost always the server. The actual endpoint of the client is + * recorded separately as CLIENT_ADDR when SERVER_RECV is logged. + */ +const string SERVER_SEND = "ss" +/** + * The server received ("sr") a request from a client. There is only one + * request per span. For example, if duplicate responses were received, each + * can be logged as a WIRE_RECV annotation. + * + * Typically, a trace starts with a server receive, so the first timestamp of a + * trace is often the timestamp of the root span's server receive. + * + * If chunking is involved, each chunk could be logged as a separate + * SERVER_RECV_FRAGMENT in the same span. + * + * Annotation.host is not the client. It is the host which logged the receive + * event, almost always the server. When logging SERVER_RECV, instrumentation + * should also log the CLIENT_ADDR. + */ +const string SERVER_RECV = "sr" +/** + * Message send ("ms") is a request to send a message to a destination, usually + * a broker. This may be the only annotation in a messaging span. If WIRE_SEND + * exists in the same span, it follows this moment and clarifies delays sending + * the message, such as batching. + * + * Unlike RPC annotations like CLIENT_SEND, messaging spans never share a span + * ID. For example, "ms" should always be the parent of "mr". + * + * Annotation.host is not the destination, it is the host which logged the send + * event: the producer. When annotating MESSAGE_SEND, instrumentation should + * also tag the MESSAGE_ADDR. + */ +const string MESSAGE_SEND = "ms" +/** + * A consumer received ("mr") a message from a broker. This may be the only + * annotation in a messaging span. If WIRE_RECV exists in the same span, it + * precedes this moment and clarifies any local queuing delay. + * + * Unlike RPC annotations like SERVER_RECV, messaging spans never share a span + * ID. For example, "mr" should always be a child of "ms" unless it is a root + * span. + * + * Annotation.host is not the broker, it is the host which logged the receive + * event: the consumer. When annotating MESSAGE_RECV, instrumentation should + * also tag the MESSAGE_ADDR. + */ +const string MESSAGE_RECV = "mr" +/** + * Optionally logs an attempt to send a message on the wire. Multiple wire send + * events could indicate network retries. A lag between client or server send + * and wire send might indicate queuing or processing delay. + */ +const string WIRE_SEND = "ws" +/** + * Optionally logs an attempt to receive a message from the wire. Multiple wire + * receive events could indicate network retries. A lag between wire receive + * and client or server receive might indicate queuing or processing delay. + */ +const string WIRE_RECV = "wr" +/** + * Optionally logs progress of a (CLIENT_SEND, WIRE_SEND). For example, this + * could be one chunk in a chunked request. + */ +const string CLIENT_SEND_FRAGMENT = "csf" +/** + * Optionally logs progress of a (CLIENT_RECV, WIRE_RECV). For example, this + * could be one chunk in a chunked response. + */ +const string CLIENT_RECV_FRAGMENT = "crf" +/** + * Optionally logs progress of a (SERVER_SEND, WIRE_SEND). For example, this + * could be one chunk in a chunked response. + */ +const string SERVER_SEND_FRAGMENT = "ssf" +/** + * Optionally logs progress of a (SERVER_RECV, WIRE_RECV). For example, this + * could be one chunk in a chunked request. + */ +const string SERVER_RECV_FRAGMENT = "srf" + +#***** BinaryAnnotation.key ****** +/** + * The domain portion of the URL or host header. Ex. "mybucket.s3.amazonaws.com" + * + * Used to filter by host as opposed to ip address. + */ +const string HTTP_HOST = "http.host" + +/** + * The HTTP method, or verb, such as "GET" or "POST". + * + * Used to filter against an http route. + */ +const string HTTP_METHOD = "http.method" + +/** + * The absolute http path, without any query parameters. Ex. "/objects/abcd-ff" + * + * Used as a filter or to clarify the request path for a given route. For example, the path for + * a route "/objects/:objectId" could be "/objects/abdc-ff". This does not limit cardinality like + * HTTP_ROUTE("http.route") can, so is not a good input to a span name. + * + * The Zipkin query api only supports equals filters. Dropping query parameters makes the number + * of distinct URIs less. For example, one can query for the same resource, regardless of signing + * parameters encoded in the query line. Dropping query parameters also limits the security impact + * of this tag. + * + * Historical note: This was commonly expressed as "http.uri" in zipkin, even though it was most + */ +const string HTTP_PATH = "http.path" + +/** + * The route which a request matched or "" (empty string) if routing is supported, but there was no + * match. Ex "/users/{userId}" + * + * Unlike HTTP_PATH("http.path"), this value is fixed cardinality, so is a safe input to a span + * name function or a metrics dimension. Different formats are possible. For example, the following + * are all valid route templates: "/users" "/users/:userId" "/users/*" + * + * Route-based span name generation often uses other tags, such as HTTP_METHOD("http.method") and + * HTTP_STATUS_CODE("http.status_code"). Route-based names can look like "get /users/{userId}", + * "post /users", "get not_found" or "get redirected". + */ +const string HTTP_ROUTE = "http.route" + +/** + * The entire URL, including the scheme, host and query parameters if available. Ex. + * "https://mybucket.s3.amazonaws.com/objects/abcd-ff?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Algorithm=AWS4-HMAC-SHA256..." + * + * Combined with HTTP_METHOD, you can understand the fully-qualified request line. + * + * This is optional as it may include private data or be of considerable length. + */ +const string HTTP_URL = "http.url" + +/** + * The HTTP status code, when not in 2xx range. Ex. "503" + * + * Used to filter for error status. + */ +const string HTTP_STATUS_CODE = "http.status_code" + +/** + * The size of the non-empty HTTP request body, in bytes. Ex. "16384" + * + * Large uploads can exceed limits or contribute directly to latency. + */ +const string HTTP_REQUEST_SIZE = "http.request.size" + +/** + * The size of the non-empty HTTP response body, in bytes. Ex. "16384" + * + * Large downloads can exceed limits or contribute directly to latency. + */ +const string HTTP_RESPONSE_SIZE = "http.response.size" + +/** + * The value of "lc" is the component or namespace of a local span. + * + * BinaryAnnotation.host adds service context needed to support queries. + * + * Local Component("lc") supports three key features: flagging, query by + * service and filtering Span.name by namespace. + * + * While structurally the same, local spans are fundamentally different than + * RPC spans in how they should be interpreted. For example, zipkin v1 tools + * center on RPC latency and service graphs. Root local-spans are neither + * indicative of critical path RPC latency, nor have impact on the shape of a + * service graph. By flagging with "lc", tools can special-case local spans. + * + * Zipkin v1 Spans are unqueryable unless they can be indexed by service name. + * The only path to a service name is by (Binary)?Annotation.host.serviceName. + * By logging "lc", a local span can be queried even if no other annotations + * are logged. + * + * The value of "lc" is the namespace of Span.name. For example, it might be + * "finatra2", for a span named "bootstrap". "lc" allows you to resolves + * conflicts for the same Span.name, for example "finatra/bootstrap" vs + * "finch/bootstrap". Using local component, you'd search for spans named + * "bootstrap" where "lc=finch" + */ +const string LOCAL_COMPONENT = "lc" + +#***** Annotation.value or BinaryAnnotation.key ****** +/** + * When an annotation value, this indicates when an error occurred. When a + * binary annotation key, the value is a human readable message associated + * with an error. + * + * Due to transient errors, an ERROR annotation should not be interpreted + * as a span failure, even the annotation might explain additional latency. + * Instrumentation should add the ERROR binary annotation when the operation + * failed and couldn't be recovered. + * + * Here's an example: A span has an ERROR annotation, added when a WIRE_SEND + * failed. Another WIRE_SEND succeeded, so there's no ERROR binary annotation + * on the span because the overall operation succeeded. + * + * Note that RPC spans often include both client and server hosts: It is + * possible that only one side perceived the error. + */ +const string ERROR = "error" + +#***** BinaryAnnotation.key where value = [1] and annotation_type = BOOL ****** +/** + * Indicates a client address ("ca") in a span. Most likely, there's only one. + * Multiple addresses are possible when a client changes its ip or port within + * a span. + */ +const string CLIENT_ADDR = "ca" +/** + * Indicates a server address ("sa") in a span. Most likely, there's only one. + * Multiple addresses are possible when a client is redirected, or fails to a + * different server ip or port. + */ +const string SERVER_ADDR = "sa" +/** + * Indicates the remote address of a messaging span, usually the broker. + */ +const string MESSAGE_ADDR = "ma" + +/** + * Indicates the network context of a service recording an annotation with two + * exceptions. + * + * When a BinaryAnnotation, and key is CLIENT_ADDR or SERVER_ADDR, + * the endpoint indicates the source or destination of an RPC. This exception + * allows zipkin to display network context of uninstrumented services, or + * clients such as web browsers. + */ +struct Endpoint { + /** + * IPv4 host address packed into 4 bytes. + * + * Ex for the ip 1.2.3.4, it would be (1 << 24) | (2 << 16) | (3 << 8) | 4 + */ + 1: i32 ipv4 + /** + * IPv4 port or 0, if unknown. + * + * Note: this is to be treated as an unsigned integer, so watch for negatives. + */ + 2: i16 port + /** + * Classifier of a source or destination in lowercase, such as "zipkin-web". + * + * This is the primary parameter for trace lookup, so should be intuitive as + * possible, for example, matching names in service discovery. + * + * Conventionally, when the service name isn't known, service_name = "unknown". + * However, it is also permissible to set service_name = "" (empty string). + * The difference in the latter usage is that the span will not be queryable + * by service name unless more information is added to the span with non-empty + * service name, e.g. an additional annotation from the server. + * + * Particularly clients may not have a reliable service name at ingest. One + * approach is to set service_name to "" at ingest, and later assign a + * better label based on binary annotations, such as user agent. + */ + 3: string service_name + /** + * IPv6 host address packed into 16 bytes. Ex Inet6Address.getBytes() + */ + 4: optional binary ipv6 +} + +/** + * Associates an event that explains latency with a timestamp. + * + * Unlike log statements, annotations are often codes: for example "sr". + */ +struct Annotation { + /** + * Microseconds from epoch. + * + * This value should use the most precise value possible. For example, + * gettimeofday or multiplying currentTimeMillis by 1000. + */ + 1: i64 timestamp + /** + * Usually a short tag indicating an event, like "sr" or "finagle.retry". + */ + 2: string value + /** + * The host that recorded the value, primarily for query by service name. + */ + 3: optional Endpoint host + // don't reuse 4: optional i32 OBSOLETE_duration // how long did the operation take? microseconds +} + +/** + * A subset of thrift base types, except BYTES. + */ +enum AnnotationType { + /** + * Set to 0x01 when key is CLIENT_ADDR or SERVER_ADDR + */ + BOOL, + /** + * No encoding, or type is unknown. + */ + BYTES, + I16, + I32, + I64, + DOUBLE, + /** + * the only type zipkin v1 supports search against. + */ + STRING +} + +/** + * Binary annotations are tags applied to a Span to give it context. For + * example, a binary annotation of HTTP_PATH ("http.path") could the path + * to a resource in a RPC call. + * + * Binary annotations of type STRING are always queryable, though more a + * historical implementation detail than a structural concern. + * + * Binary annotations can repeat, and vary on the host. Similar to Annotation, + * the host indicates who logged the event. This allows you to tell the + * difference between the client and server side of the same key. For example, + * the key "http.path" might be different on the client and server side due to + * rewriting, like "/api/v1/myresource" vs "/myresource. Via the host field, + * you can see the different points of view, which often help in debugging. + */ +struct BinaryAnnotation { + /** + * Name used to lookup spans, such as "http.path" or "finagle.version". + */ + 1: string key, + /** + * Serialized thrift bytes, in TBinaryProtocol format. + * + * For legacy reasons, byte order is big-endian. See THRIFT-3217. + */ + 2: binary value, + /** + * The thrift type of value, most often STRING. + * + * annotation_type shouldn't vary for the same key. + */ + 3: AnnotationType annotation_type, + /** + * The host that recorded value, allowing query by service name or address. + * + * There are two exceptions: when key is "ca" or "sa", this is the source or + * destination of an RPC. This exception allows zipkin to display network + * context of uninstrumented services, such as browsers or databases. + */ + 4: optional Endpoint host +} + +/** + * A trace is a series of spans (often RPC calls) which form a latency tree. + * + * Spans are usually created by instrumentation in RPC clients or servers, but + * can also represent in-process activity. Annotations in spans are similar to + * log statements, and are sometimes created directly by application developers + * to indicate events of interest, such as a cache miss. + * + * The root span is where parent_id = Nil; it usually has the longest duration + * in the trace. + * + * Span identifiers are packed into i64s, but should be treated opaquely. + * String encoding is fixed-width lower-hex, to avoid signed interpretation. + */ +struct Span { + /** + * Unique 8-byte identifier for a trace, set on all spans within it. + */ + 1: i64 trace_id + /** + * Span name in lowercase, rpc method for example. Conventionally, when the + * span name isn't known, name = "unknown". + */ + 3: string name, + /** + * Unique 8-byte identifier of this span within a trace. A span is uniquely + * identified in storage by (trace_id, id). + */ + 4: i64 id, + /** + * The parent's Span.id; absent if this the root span in a trace. + */ + 5: optional i64 parent_id, + /** + * Associates events that explain latency with a timestamp. Unlike log + * statements, annotations are often codes: for example SERVER_RECV("sr"). + * Annotations are sorted ascending by timestamp. + */ + 6: list annotations, + /** + * Tags a span with context, usually to support query or aggregation. For + * example, a binary annotation key could be "http.path". + */ + 8: list binary_annotations + /** + * True is a request to store this span even if it overrides sampling policy. + */ + 9: optional bool debug = 0 + /** + * Epoch microseconds of the start of this span, absent if this an incomplete + * span. + * + * This value should be set directly by instrumentation, using the most + * precise value possible. For example, gettimeofday or syncing nanoTime + * against a tick of currentTimeMillis. + * + * For compatibility with instrumentation that precede this field, collectors + * or span stores can derive this via Annotation.timestamp. + * For example, SERVER_RECV.timestamp or CLIENT_SEND.timestamp. + * + * Timestamp is nullable for input only. Spans without a timestamp cannot be + * presented in a timeline: Span stores should not output spans missing a + * timestamp. + * + * There are two known edge-cases where this could be absent: both cases + * exist when a collector receives a span in parts and a binary annotation + * precedes a timestamp. This is possible when.. + * - The span is in-flight (ex not yet received a timestamp) + * - The span's start event was lost + */ + 10: optional i64 timestamp, + /** + * Measurement in microseconds of the critical path, if known. Durations of + * less than one microsecond must be rounded up to 1 microsecond. + * + * This value should be set directly, as opposed to implicitly via annotation + * timestamps. Doing so encourages precision decoupled from problems of + * clocks, such as skew or NTP updates causing time to move backwards. + * + * For compatibility with instrumentation that precede this field, collectors + * or span stores can derive this by subtracting Annotation.timestamp. + * For example, SERVER_SEND.timestamp - SERVER_RECV.timestamp. + * + * If this field is persisted as unset, zipkin will continue to work, except + * duration query support will be implementation-specific. Similarly, setting + * this field non-atomically is implementation-specific. + * + * This field is i64 vs i32 to support spans longer than 35 minutes. + */ + 11: optional i64 duration + /** + * Optional unique 8-byte additional identifier for a trace. If non zero, this + * means the trace uses 128 bit traceIds instead of 64 bit. + */ + 12: optional i64 trace_id_high +} diff --git a/public/zipkin-api/thrift/zipkinDependencies.thrift b/public/zipkin-api/thrift/zipkinDependencies.thrift new file mode 100644 index 0000000..30ce57d --- /dev/null +++ b/public/zipkin-api/thrift/zipkinDependencies.thrift @@ -0,0 +1,38 @@ +# Copyright 2013 Twitter Inc. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +namespace java com.twitter.zipkin.thriftjava +#@namespace scala com.twitter.zipkin.thriftscala +namespace rb Zipkin + +struct DependencyLink { + /** parent service name (caller) */ + 1: string parent + /** child service name (callee) */ + 2: string child + # 3: Moments OBSOLETE_duration_moments + /** total traced calls made from parent to child */ + 4: i64 callCount + /** how many calls are known to be errors */ + 5: i64 errorCount + # histogram? +} + +/* An aggregate representation of services paired with every service they call. */ +struct Dependencies { + /** milliseconds from epoch */ + 1: i64 start_ts + /** milliseconds from epoch */ + 2: i64 end_ts + 3: list links +} diff --git a/public/zipkin-api/validate.js b/public/zipkin-api/validate.js new file mode 100644 index 0000000..b7e7140 --- /dev/null +++ b/public/zipkin-api/validate.js @@ -0,0 +1,31 @@ +'use strict'; + +const Sway = require('sway'); +const read = require('fs').readFileSync; +const load = require('js-yaml').load; +const yamls = ['./zipkin-api.yaml', './zipkin2-api.yaml']; + +yamls.forEach(yaml => { + const zipkinAPI = read(yaml).toString(); + + Sway.create({definition: load(zipkinAPI)}).then(api => { + const result = api.validate(); + + if (result.errors.length) { + console.error(`Validation failed for ${yaml}`) + console.error(JSON.stringify(result.errors)); + return; + } + + if (result.warnings.length) { + console.warn(`Warnings in ${yaml}:`) + console.warn(JSON.stringify(result.warnings)); + } + + console.log(`Validation of ${yaml} passed`); + }) + .catch(error=> { + console.error(`Error loading ${yaml}`); + console.error(error); + }); +}); diff --git a/public/zipkin-api/zipkin-api.yaml b/public/zipkin-api/zipkin-api.yaml new file mode 100644 index 0000000..3330b64 --- /dev/null +++ b/public/zipkin-api/zipkin-api.yaml @@ -0,0 +1,423 @@ +swagger: "2.0" +info: + version: "1.0.0" + title: Zipkin API + description: | + Zipkin's Query api is rooted at `api/v1`, on a host that by default listens + on port 9411. It primarily serves the zipkin-ui, although it includes a POST + endpoint that can receive spans. +host: localhost:9411 +basePath: /api/v1 +schemes: + - http + - https +consumes: + - application/json +produces: + - application/json +paths: + /services: + get: + description: | + Returns a list of all service names associated with annotations. + responses: + '200': + description: Succes + schema: + type: array + items: + type: string + '400': + description: Bad Request Error + /spans: + get: + description: Get all the span names logged by a particular service + parameters: + - name: serviceName + in: query + required: true + description: | + Ex zipkin-server (required) - service that logged an annotation in a + trace. The /services endpoint enumerates possible input values. + type: string + responses: + '200': + description: OK + schema: + type: array + items: + type: string + '400': + description: Bad Request Error + post: + description: | + Uploads a list of spans encoded per content-type, for example json + or thrift (TBinaryProtocol big-endian). + consumes: + - application/json + - application/x-thrift + produces: [] + parameters: + - name: span + in: body + description: A list of spans that belong to any trace. + required: true + schema: + $ref: "#/definitions/ListOfSpans" + responses: + '202': + description: Accepted + /traces: + get: + description: | + Invoking this request retrieves traces matching the below filters. + + Results should be filtered against endTs, subject to limit and + lookback. For example, if endTs is 10:20 today, limit is 10, and + lookback is 7 days, traces returned should be those nearest to 10:20 + today, not 10:20 a week ago. + + Time units of endTs and lookback are milliseconds as opposed to + microseconds, the grain of Span.timestamp. Milliseconds is a more + familiar and supported granularity for query, index and windowing + functions + parameters: + - name: serviceName + in: query + required: false + description: | + Ex zipkin-server - service that logged an annotation in a trace. + Required when constraining on parameters except time and duration. + The /services endpoint enumerates possible input values. + type: string + - name: spanName + in: query + required: false + description: | + Ex my_span_name - name of a span in a trace. + Only return traces that contains spans with this name. + type: string + - name: annotationQuery + in: query + type: string + required: false + description: | + Ex. `http.uri=/foo and retried` - If key/value (has an `=`), + constrains against Span.binaryAnnotations of time string. If just + a word, constrains against Span.annotations. Any values are AND + against eachother. This means a span in the trace must match all of + these. + - name: minDuration + in: query + type: integer + description: | + Ex. 100000 (for 100ms). Only return traces whose `Span.duration` is + greater than or equal to minDuration microseconds. + - name: maxDuration + in: query + type: integer + description: | + Only return traces whose Span.duration is less than or equal to + `maxDuration` microseconds. Only valid with minDuration. + - name: endTs + in: query + type: integer + format: int64 + description: | + Only return traces where all Span.timestamp are at or before this + time in epoch milliseconds. Defaults to current time. + - name: lookback + type: integer + format: int64 + in: query + description: | + Only return traces where all Span.timestamp are at or after + (`endTs - * lookback`) in milliseconds. Defaults to `endTs`, limited + to a system parameter `QUERY_LOOKBACK`. + - name: limit + in: query + default: 10 + type: integer + description: | + Maximum number of traces to return. Defaults to 10 + responses: + '200': + description: OK + schema: + $ref: "#/definitions/ListOfTraces" + /trace/{traceId}: + get: + parameters: + - name: traceId + in: path + required: true + description: the 64 or 128-bit hex-encoded id of the trace as a path parameter. + type: string + - name: raw + in: query + required: false + description: | + Note this flag has no value. Ex. /trace/{traceId}?raw + + Normally, the trace endpoint cleans trace data. For example, it merges + spans by id, adds missing timestamp or duration, corrects clock skew.. + + Specifying this flag is a debug case, when you are debugging zipkin + logic or zipkin instrumentation, and want to see the input to these + adjusters. For example, this might explain or rule out clock skew. + type: boolean + responses: + '200': + description: OK + schema: + $ref: "#/definitions/Trace" + '404': + description: "`traceId` not found" + /dependencies: + get: + description: | + Returns dependency links derived from spans. + + Span names are in lowercase, rpc method for example. Conventionally, + when the span name isn't known, name = "unknown". + parameters: + - name: endTs + in: query + description: | + Only return links from spans where `Span.timestamp` are at or before + this time in epoch milliseconds. + required: true + type: integer + format: int64 + - name: lookback + in: query + description: | + Only return links from spans where all Span.timestamp are at or after + (`endTs - * lookback`) in milliseconds. Defaults to `endTs`, limited + to a system parameter `QUERY_LOOKBACK`. + type: integer + format: int64 + responses: + '200': + description: OK + schema: + type: array + title: ListOfDependencyLinks + items: + $ref: "#/definitions/DependencyLink" +definitions: + Endpoint: + type: object + title: Endpoint + description: The network context of a node in the service graph + required: + - serviceName + properties: + serviceName: + type: string + description: | + Lower-case label of this node in the service graph, such as "favstar". Set + to empty string if unknown. + + This is a primary label for trace lookup and aggregation, so it should be + intuitive and consistent. Many use a name from service discovery. + ipv4: + type: string + format: ipv4 + description: | + The text representation of the primary IPv4 address associated with this + connection. Ex. 192.168.99.100 Absent if unknown. + ipv6: + type: string + format: ipv6 + description: | + The text representation of the primary IPv6 address associated with a + connection. Ex. 2001:db8::c001 Absent if unknown. + + Prefer using the ipv4 field for mapped addresses. + port: + type: integer + description: | + Depending on context, this could be a listen port or the client-side of a + socket. Absent if unknown. Please don't set to zero. + Annotation: + title: Annotation + type: object + required: + - timestamp + - value + description: | + Associates an event that explains latency with a timestamp. + Unlike log statements, annotations are often codes. Ex. "sr" for ServerReceive + properties: + timestamp: + type: integer + description: | + Epoch **microseconds** of this event. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most precise + value possible. For example, gettimeofday or multiplying epoch millis by 1000. + value: + type: string + description: | + Usually a short tag indicating an event, like "sr" + + While possible to add larger data, such as garbage collection details, low + cardinality event names both keep the size of spans down and also are easy + to search against. + endpoint: + $ref: "#/definitions/Endpoint" + description: | + The host that recorded this span, primarily for query by service name. + + Instrumentation should always record this. Usually, absent implies late + data. The IP address corresponding to this is usually the site local or + advertised service address. When present, the port indicates the listen + port. + BinaryAnnotation: + title: BinaryAnnotation + type: object + required: + - key + - value + description: | + Adds context to a span, for search, viewing and analysis. + + For example, a key "your_app.version" would let you lookup traces by version. + A tag "sql.query" isn't searchable, but it can help in debugging when viewing + a trace. + properties: + key: + type: string + value: + type: string + endpoint: + $ref: "#/definitions/Endpoint" + description: | + The host that recorded this span, primarily for query by service name. + + There is an exception, when the key is "sa", "ca" or "ma" this is an + address annotation. In such case, the endpoint is not what recorded the + span, rather the remote address. The value field is set to boolean true + in this case. This feature was refactored in v2 format as "remoteEndpoint" + ListOfSpans: + title: ListOfSpans + description: 'A list of spans with possibly different trace ids, in no particular order' + type: array + items: + $ref: "#/definitions/Span" + Trace: + title: Trace + type: array + description: 'List of spans who have the same trace id. Spans in the trace, and annotations in a span are sorted ascending by timestamp. ie first event should be first in the spans list.' + items: + $ref: "#/definitions/Span" + ListOfTraces: + title: ListOfTraces + type: array + items: + $ref: "#/definitions/Trace" + Span: + title: Span + type: object + required: + - traceId + - id + - name + properties: + traceId: + type: string + maxLength: 32 + minLength: 16 + pattern: "[a-z0-9]{16,32}" + description: | + Randomly generated, unique identifier for a trace, set on all spans within it. + + Encoded as 16 or 32 lowercase hex characters corresponding to 64 or 128 bits. + For example, a 128bit trace ID looks like 4e441824ec2b6a44ffdc9bb9a6453df3 + name: + type: string + description: | + The logical operation this span represents in lowercase (e.g. rpc method). + Set to empty string if unknown. + + As these are lookup labels, take care to ensure names are low cardinality. + For example, do not embed variables into the name. + parentId: + type: string + pattern: "[a-z0-9]{16}" + maxLength: 16 + minLength: 16 + description: 'The parent span ID or absent if this the root span in a trace.' + id: + type: string + maxLength: 16 + minLength: 16 + pattern: "[a-z0-9]{16}" + description: | + Unique 64bit identifier for this operation within the trace. + + Encoded as 16 lowercase hex characters. For example ffdc9bb9a6453df3 + timestamp: + type: integer + format: int64 + description: | + Epoch microseconds of the start of this span, possibly absent if + incomplete. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most + precise value possible. For example, gettimeofday or multiplying epoch + millis by 1000. + + There are three known edge-cases where this could be reported absent. + * A span was allocated but never started (ex not yet received a timestamp) + * The span's start event was lost + * Data about a completed span (ex tags) were sent after the fact + duration: + type: integer + format: int64 + minimum: 1 + description: | + Duration in **microseconds** of the critical path, if known. Durations of less + than one are rounded up. Duration of children can be longer than their + parents due to asynchronous operations. + + For example 150 milliseconds is 150000 microseconds. + debug: + type: boolean + description: | + True is a request to store this span even if it overrides sampling policy. + + This is true when the `X-B3-Flags` header has a value of 1. + annotations: + title: ListOfAnnotations + type: array + description: 'Associates events that explain latency with the time they happened.' + items: + $ref: '#/definitions/Annotation' + binaryAnnotations: + title: ListOfBinaryAnnotations + type: array + description: 'Binary Annotations are tags that give your span context for search, viewing and analysis.' + items: + $ref: '#/definitions/BinaryAnnotation' + DependencyLink: + title: DependencyLink + type: object + required: + - parent + - child + - callCount + properties: + parent: + type: string + child: + type: string + callCount: + type: integer + errorCount: + type: integer diff --git a/public/zipkin-api/zipkin.proto b/public/zipkin-api/zipkin.proto new file mode 100644 index 0000000..9a4b336 --- /dev/null +++ b/public/zipkin-api/zipkin.proto @@ -0,0 +1,213 @@ +// Copyright 2018 The OpenZipkin Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +syntax = "proto3"; + +package zipkin.proto3; + +// In Java, the closest model type to this proto is in the "zipkin2" package +option java_package = "zipkin2.proto3"; +option java_multiple_files = true; + +// A span is a single-host view of an operation. A trace is a series of spans +// (often RPC calls) which nest to form a latency tree. Spans are in the same +// trace when they share the same trace ID. The parent_id field establishes the +// position of one span in the tree. +// +// The root span is where parent_id is Absent and usually has the longest +// duration in the trace. However, nested asynchronous work can materialize as +// child spans whose duration exceed the root span. +// +// Spans usually represent remote activity such as RPC calls, or messaging +// producers and consumers. However, they can also represent in-process +// activity in any position of the trace. For example, a root span could +// represent a server receiving an initial client request. A root span could +// also represent a scheduled job that has no remote context. +// +// Encoding notes: +// +// Epoch timestamp are encoded fixed64 as varint would also be 8 bytes, and more +// expensive to encode and size. Duration is stored uint64, as often the numbers +// are quite small. +// +// Default values are ok, as only natural numbers are used. For example, zero is +// an invalid timestamp and an invalid duration, false values for debug or shared +// are ignorable, and zero-length strings also coerce to null. +// +// The next id is 14. +// +// Note fields up to 15 take 1 byte to encode. Take care when adding new fields +// https://developers.google.com/protocol-buffers/docs/proto3#assigning-tags +message Span { + // Randomly generated, unique identifier for a trace, set on all spans within + // it. + // + // This field is required and encoded as 8 or 16 opaque bytes. + bytes trace_id = 1; + // The parent span ID or absent if this the root span in a trace. + bytes parent_id = 2; + // Unique identifier for this operation within the trace. + // + // This field is required and encoded as 8 opaque bytes. + bytes id = 3; + // When present, kind clarifies timestamp, duration and remote_endpoint. When + // absent, the span is local or incomplete. Unlike client and server, there + // is no direct critical path latency relationship between producer and + // consumer spans. + enum Kind { + // Default value interpreted as absent. + SPAN_KIND_UNSPECIFIED = 0; + // The span represents the client side of an RPC operation, implying the + // following: + // + // timestamp is the moment a request was sent to the server. + // duration is the delay until a response or an error was received. + // remote_endpoint is the server. + CLIENT = 1; + // The span represents the server side of an RPC operation, implying the + // following: + // + // timestamp is the moment a client request was received. + // duration is the delay until a response was sent or an error. + // remote_endpoint is the client. + SERVER = 2; + // The span represents production of a message to a remote broker, implying + // the following: + // + // timestamp is the moment a message was sent to a destination. + // duration is the delay sending the message, such as batching. + // remote_endpoint is the broker. + PRODUCER = 3; + // The span represents consumption of a message from a remote broker, not + // time spent servicing it. For example, a message processor would be an + // in-process child span of a consumer. Consumer spans imply the following: + // + // timestamp is the moment a message was received from an origin. + // duration is the delay consuming the message, such as from backlog. + // remote_endpoint is the broker. + CONSUMER = 4; + } + // When present, used to interpret remote_endpoint + Kind kind = 4; + // The logical operation this span represents in lowercase (e.g. rpc method). + // Leave absent if unknown. + // + // As these are lookup labels, take care to ensure names are low cardinality. + // For example, do not embed variables into the name. + string name = 5; + // Epoch microseconds of the start of this span, possibly absent if + // incomplete. + // + // For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + // + // This value should be set directly by instrumentation, using the most + // precise value possible. For example, gettimeofday or multiplying epoch + // millis by 1000. + // + // There are three known edge-cases where this could be reported absent. + // - A span was allocated but never started (ex not yet received a timestamp) + // - The span's start event was lost + // - Data about a completed span (ex tags) were sent after the fact + fixed64 timestamp = 6; + // Duration in microseconds of the critical path, if known. Durations of less + // than one are rounded up. Duration of children can be longer than their + // parents due to asynchronous operations. + // + // For example 150 milliseconds is 150000 microseconds. + uint64 duration = 7; + // The host that recorded this span, primarily for query by service name. + // + // Instrumentation should always record this. Usually, absent implies late + // data. The IP address corresponding to this is usually the site local or + // advertised service address. When present, the port indicates the listen + // port. + Endpoint local_endpoint = 8; + // When an RPC (or messaging) span, indicates the other side of the + // connection. + // + // By recording the remote endpoint, your trace will contain network context + // even if the peer is not tracing. For example, you can record the IP from + // the "X-Forwarded-For" header or the service name and socket of a remote + // peer. + Endpoint remote_endpoint = 9; + // Associates events that explain latency with the time they happened. + repeated Annotation annotations = 10; + // Tags give your span context for search, viewing and analysis. + // + // For example, a key "your_app.version" would let you lookup traces by + // version. A tag "sql.query" isn't searchable, but it can help in debugging + // when viewing a trace. + map tags = 11; + // True is a request to store this span even if it overrides sampling policy. + // + // This is true when the "X-B3-Flags" header has a value of 1. + bool debug = 12; + // True if we are contributing to a span started by another tracer (ex on a + // different host). + bool shared = 13; +} + +// The network context of a node in the service graph. +// +// The next id is 5. +message Endpoint { + // Lower-case label of this node in the service graph, such as "favstar". + // Leave absent if unknown. + // + // This is a primary label for trace lookup and aggregation, so it should be + // intuitive and consistent. Many use a name from service discovery. + string service_name = 1; + // 4 byte representation of the primary IPv4 address associated with this + // connection. Absent if unknown. + bytes ipv4 = 2; + // 16 byte representation of the primary IPv6 address associated with this + // connection. Absent if unknown. + // + // Prefer using the ipv4 field for mapped addresses. + bytes ipv6 = 3; + // Depending on context, this could be a listen port or the client-side of a + // socket. Absent if unknown. + int32 port = 4; +} + +// Associates an event that explains latency with a timestamp. +// Unlike log statements, annotations are often codes. Ex. "ws" for WireSend +// +// The next id is 3. +message Annotation { + // Epoch microseconds of this event. + // + // For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + // + // This value should be set directly by instrumentation, using the most + // precise value possible. For example, gettimeofday or multiplying epoch + // millis by 1000. + fixed64 timestamp = 1; + // Usually a short tag indicating an event, like "error" + // + // While possible to add larger data, such as garbage collection details, low + // cardinality event names both keep the size of spans down and also are easy + // to search against. + string value = 2; +} + +// A list of spans with possibly different trace ids, in no particular order. +// +// This is used for all transports: POST, Kafka messages etc. No other fields +// are expected, This message facilitates the mechanics of encoding a list, as +// a field number is required. The name of this type is the same in the OpenApi +// aka Swagger specification. https://zipkin.io/zipkin-api/#/default/post_spans +message ListOfSpans { + repeated Span spans = 1; +} diff --git a/public/zipkin-api/zipkin2-api.yaml b/public/zipkin-api/zipkin2-api.yaml new file mode 100644 index 0000000..2aa6ff9 --- /dev/null +++ b/public/zipkin-api/zipkin2-api.yaml @@ -0,0 +1,464 @@ +swagger: "2.0" +info: + version: "1.0.0" + title: Zipkin API + description: | + Zipkin's v2 api currently includes a POST endpoint that can receive spans. +host: localhost:9411 +basePath: /api/v2 +schemes: + - http + - https +consumes: + - application/json +paths: + /services: + get: + description: | + Returns a list of all service names associated with span endpoints. + responses: + '200': + description: Succes + schema: + type: array + items: + type: string + '400': + description: Bad Request Error + /spans: + get: + description: Get all the span names recorded by a particular service + parameters: + - name: serviceName + in: query + required: true + description: | + Ex favstar (required) - Lower-case label of a node in the service + graph. The /services endpoint enumerates possible input values. + type: string + responses: + '200': + description: OK + schema: + type: array + items: + type: string + '400': + description: Bad Request Error + post: + description: | + Uploads a list of spans encoded per content-type, for example json. + consumes: + - application/json + - application/x-protobuf + produces: [] + parameters: + - name: spans + in: body + description: A list of spans that belong to any trace. + required: true + schema: + $ref: "#/definitions/ListOfSpans" + responses: + '202': + description: Accepted + /traces: + get: + description: | + Invoking this request retrieves traces matching the below filters. + + Results should be filtered against endTs, subject to limit and + lookback. For example, if endTs is 10:20 today, limit is 10, and + lookback is 7 days, traces returned should be those nearest to 10:20 + today, not 10:20 a week ago. + + Time units of endTs and lookback are milliseconds as opposed to + microseconds, the grain of Span.timestamp. Milliseconds is a more + familiar and supported granularity for query, index and windowing + functions + parameters: + - name: serviceName + in: query + required: false + description: | + Ex favstar (required) - Lower-case label of a node in the service + graph. The /services endpoint enumerates possible input values. + type: string + - name: spanName + in: query + required: false + description: | + Ex get - name of a span in a trace. + Only return traces that contains spans with this name. + type: string + - name: annotationQuery + in: query + type: string + required: false + description: | + Ex. `http.uri=/foo and retried` - If key/value (has an `=`), + constrains against Span.tags entres. If just a word, constrains + against Span.annotations[].value or Span.tags[].key. Any values are + AND against eachother. This means a span in the trace must match + all of these. + - name: minDuration + in: query + type: integer + description: | + Ex. 100000 (for 100ms). Only return traces whose `Span.duration` is + greater than or equal to minDuration microseconds. + - name: maxDuration + in: query + type: integer + description: | + Only return traces whose Span.duration is less than or equal to + `maxDuration` microseconds. Only valid with minDuration. + - name: endTs + in: query + type: integer + format: int64 + description: | + Only return traces where all Span.timestamp are at or before this + time in epoch milliseconds. Defaults to current time. + - name: lookback + type: integer + format: int64 + in: query + description: | + Only return traces where all Span.timestamp are at or after (endTs + - * lookback) in milliseconds. Defaults to endTs, limited to a + system parameter QUERY_LOOKBACK + - name: limit + in: query + default: 10 + type: integer + description: | + Maximum number of traces to return. Defaults to 10 + responses: + '200': + description: OK + schema: + $ref: "#/definitions/ListOfTraces" + /trace/{traceId}: + get: + parameters: + - name: traceId + in: path + required: true + type: string + maxLength: 32 + minLength: 16 + pattern: "[a-z0-9]{16,32}" + description: | + Trace identifier, set on all spans within it. + + Encoded as 16 or 32 lowercase hex characters corresponding to 64 or 128 bits. + For example, a 128bit trace ID looks like 4e441824ec2b6a44ffdc9bb9a6453df3 + responses: + '200': + description: OK + schema: + $ref: "#/definitions/Trace" + '404': + description: "`traceId` not found" + /dependencies: + get: + description: | + Returns service links derived from spans. + parameters: + - name: endTs + in: query + description: | + only return links from spans where `Span.timestamp` are at or before + this time in epoch milliseconds. + required: true + type: integer + format: int64 + - name: lookback + in: query + description: | + only return links where all Span.timestamp are at or after + (`endTs - * lookback`) in milliseconds. Defaults to `endTs`, limited + to a system parameter `QUERY_LOOKBACK` + type: integer + format: int64 + responses: + '200': + description: OK + schema: + type: array + title: ListOfDependencyLinks + items: + $ref: "#/definitions/DependencyLink" +definitions: + Endpoint: + type: object + title: Endpoint + description: The network context of a node in the service graph + properties: + serviceName: + type: string + description: | + Lower-case label of this node in the service graph, such as "favstar". Leave + absent if unknown. + + This is a primary label for trace lookup and aggregation, so it should be + intuitive and consistent. Many use a name from service discovery. + ipv4: + type: string + format: ipv4 + description: | + The text representation of the primary IPv4 address associated with this + connection. Ex. 192.168.99.100 Absent if unknown. + ipv6: + type: string + format: ipv6 + description: | + The text representation of the primary IPv6 address associated with a + connection. Ex. 2001:db8::c001 Absent if unknown. + + Prefer using the ipv4 field for mapped addresses. + port: + type: integer + description: | + Depending on context, this could be a listen port or the client-side of a + socket. Absent if unknown. Please don't set to zero. + Annotation: + title: Annotation + type: object + description: | + Associates an event that explains latency with a timestamp. + Unlike log statements, annotations are often codes. Ex. "ws" for WireSend + + Zipkin v1 core annotations such as "cs" and "sr" have been replaced with + Span.Kind, which interprets timestamp and duration. + required: + - timestamp + - value + properties: + timestamp: + type: integer + description: | + Epoch **microseconds** of this event. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most precise + value possible. For example, gettimeofday or multiplying epoch millis by 1000. + value: + type: string + description: | + Usually a short tag indicating an event, like "error" + + While possible to add larger data, such as garbage collection details, low + cardinality event names both keep the size of spans down and also are easy + to search against. + Tags: + type: object + title: Tags + description: | + Adds context to a span, for search, viewing and analysis. + + For example, a key "your_app.version" would let you lookup traces by version. + A tag "sql.query" isn't searchable, but it can help in debugging when viewing + a trace. + additionalProperties: + type: string + ListOfSpans: + title: ListOfSpans + description: 'A list of spans with possibly different trace ids, in no particular order' + type: array + items: + $ref: "#/definitions/Span" + Trace: + title: Trace + type: array + description: 'List of spans who have the same trace ID.' + items: + $ref: "#/definitions/Span" + ListOfTraces: + title: ListOfTraces + type: array + items: + $ref: "#/definitions/Trace" + Span: + title: Span + description: | + A span is a single-host view of an operation. A trace is a series of spans + (often RPC calls) which nest to form a latency tree. Spans are in the same + trace when they share the same trace ID. The parent_id field establishes the + position of one span in the tree. + + The root span is where parent_id is Absent and usually has the longest + duration in the trace. However, nested asynchronous work can materialize as + child spans whose duration exceed the root span. + + Spans usually represent remote activity such as RPC calls, or messaging + producers and consumers. However, they can also represent in-process + activity in any position of the trace. For example, a root span could + represent a server receiving an initial client request. A root span could + also represent a scheduled job that has no remote context. + type: object + required: + - traceId + - id + properties: + traceId: + type: string + maxLength: 32 + minLength: 16 + pattern: "[a-z0-9]{16,32}" + description: | + Randomly generated, unique identifier for a trace, set on all spans within it. + + Encoded as 16 or 32 lowercase hex characters corresponding to 64 or 128 bits. + For example, a 128bit trace ID looks like 4e441824ec2b6a44ffdc9bb9a6453df3 + name: + type: string + description: | + The logical operation this span represents in lowercase (e.g. rpc method). + Leave absent if unknown. + + As these are lookup labels, take care to ensure names are low cardinality. + For example, do not embed variables into the name. + parentId: + type: string + pattern: "[a-z0-9]{16}" + maxLength: 16 + minLength: 16 + description: 'The parent span ID or absent if this the root span in a trace.' + id: + type: string + pattern: "[a-z0-9]{16}" + maxLength: 16 + minLength: 16 + description: | + Unique 64bit identifier for this operation within the trace. + + Encoded as 16 lowercase hex characters. For example ffdc9bb9a6453df3 + kind: + type: string + enum: + - CLIENT + - SERVER + - PRODUCER + - CONSUMER + description: | + When present, kind clarifies timestamp, duration and remoteEndpoint. When + absent, the span is local or incomplete. Unlike client and server, there + is no direct critical path latency relationship between producer and + consumer spans. + + * `CLIENT` + * timestamp is the moment a request was sent to the server. (in v1 "cs") + * duration is the delay until a response or an error was received. (in v1 "cr"-"cs") + * remoteEndpoint is the server. (in v1 "sa") + * `SERVER` + * timestamp is the moment a client request was received. (in v1 "sr") + * duration is the delay until a response was sent or an error. (in v1 "ss"-"sr") + * remote_endpoint is the client. (in v1 "ca") + * `PRODUCER` + * timestamp is the moment a message was sent to a destination. (in v1 "ms") + * duration is the delay sending the message, such as batching. + * remoteEndpoint is the broker. + * `CONSUMER` + * timestamp is the moment a message was received from an origin. (in v1 "mr") + * duration is the delay consuming the message, such as from backlog. + * remoteEndpoint - Represents the broker. Leave serviceName absent if unknown. + timestamp: + type: integer + format: int64 + description: | + Epoch microseconds of the start of this span, possibly absent if + incomplete. + + For example, 1502787600000000 corresponds to 2017-08-15 09:00 UTC + + This value should be set directly by instrumentation, using the most + precise value possible. For example, gettimeofday or multiplying epoch + millis by 1000. + + There are three known edge-cases where this could be reported absent. + * A span was allocated but never started (ex not yet received a timestamp) + * The span's start event was lost + * Data about a completed span (ex tags) were sent after the fact + duration: + type: integer + format: int64 + minimum: 1 + description: | + Duration in **microseconds** of the critical path, if known. Durations of less + than one are rounded up. Duration of children can be longer than their + parents due to asynchronous operations. + + For example 150 milliseconds is 150000 microseconds. + debug: + type: boolean + description: | + True is a request to store this span even if it overrides sampling policy. + + This is true when the `X-B3-Flags` header has a value of 1. + shared: + type: boolean + description: 'True if we are contributing to a span started by another tracer (ex on a different host).' + localEndpoint: + $ref: "#/definitions/Endpoint" + description: | + The host that recorded this span, primarily for query by service name. + + Instrumentation should always record this. Usually, absent implies late + data. The IP address corresponding to this is usually the site local or + advertised service address. When present, the port indicates the listen + port. + remoteEndpoint: + $ref: "#/definitions/Endpoint" + description: | + When an RPC (or messaging) span, indicates the other side of the + connection. + + By recording the remote endpoint, your trace will contain network context + even if the peer is not tracing. For example, you can record the IP from + the `X-Forwarded-For` header or the service name and socket of a remote + peer. + annotations: + type: array + uniqueItems: true + items: + $ref: '#/definitions/Annotation' + description: 'Associates events that explain latency with the time they happened.' + tags: + $ref: '#/definitions/Tags' + description: 'Tags give your span context for search, viewing and analysis.' + DependencyLink: + title: DependencyLink + description: | + The count of traced calls between services, or between a service and a broker. + + The direction of the link is parent to child, and can be one of: + * client to server + * producer to broker + * broker to consumer + + Note: This is related to span ID count between a sender and receiver, but there + is nuance that makes it more difficult than counting unique span IDs. Ex. the + parent or child might be uninstrumented: detected via the remote endpoint. There + can also be scenarios where both sides are instrumented. Please use existing tools + such as zipkin-dependencies to derive links as they avoid under or over counting. + type: object + required: + - parent + - child + - callCount + properties: + parent: + type: string + description: 'The service name of the caller: client or message producer or broker.' + child: + type: string + description: 'The service name of the callee: server or message consumer or broker.' + callCount: + type: integer + description: 'Total traced calls made from the parent to the child.' + errorCount: + type: integer + description: 'Total traced calls made from the parent to the child known to be in error.'