Last active
August 29, 2015 14:07
-
-
Save jroyalty/3fee3964fb0a0c5f2fee to your computer and use it in GitHub Desktop.
A Javascript-based query library for time series data. This is particular to OpenTSDB-style data at the moment.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. | |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
* | |
* This code is free software; you can redistribute it and/or modify it | |
* under the terms of the GNU General Public License version 2 only, as | |
* published by the Free Software Foundation. Oracle designates this | |
* particular file as subject to the "Classpath" exception as provided | |
* by Oracle in the LICENSE file that accompanied this code. | |
* | |
* This code is distributed in the hope that it will be useful, but WITHOUT | |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
* version 2 for more details (a copy is included in the LICENSE file that | |
* accompanied this code). | |
* | |
* You should have received a copy of the GNU General Public License version | |
* 2 along with this work; if not, write to the Free Software Foundation, | |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
* | |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
* or visit www.oracle.com if you need additional information or have any | |
* questions. | |
*/ | |
/** | |
* jrunscript JavaScript built-in functions and objects. | |
*/ | |
/** | |
* Creates an object that delegates all method calls on | |
* it to the 'invoke' method on the given delegate object.<br> | |
* | |
* Example: | |
* <pre> | |
* <code> | |
* var x = { invoke: function(name, args) { //code...} | |
* var y = new JSInvoker(x); | |
* y.func(3, 3); // calls x.invoke('func', args); where args is array of arguments | |
* </code> | |
* </pre> | |
* @param obj object to be wrapped by JSInvoker | |
* @constructor | |
*/ | |
function JSInvoker(obj) { | |
return new JSAdapter({ | |
__get__ : function(name) { | |
return function() { | |
return obj.invoke(name, arguments); | |
} | |
} | |
}); | |
} | |
/** | |
* This variable represents OS environment. Environment | |
* variables can be accessed as fields of this object. For | |
* example, env.PATH will return PATH value configured. | |
*/ | |
var env = new JSAdapter({ | |
__get__ : function (name) { | |
return java.lang.System.getenv(name); | |
}, | |
__has__ : function (name) { | |
return java.lang.System.getenv().containsKey(name); | |
}, | |
__getIds__ : function() { | |
return java.lang.System.getenv().keySet().toArray(); | |
}, | |
__delete__ : function(name) { | |
println("can't delete env item"); | |
}, | |
__put__ : function (name, value) { | |
println("can't change env item"); | |
}, | |
toString: function() { | |
return java.lang.System.getenv().toString(); | |
} | |
}); | |
/** | |
* Creates a convenient script object to deal with java.util.Map instances. | |
* The result script object's field names are keys of the Map. For example, | |
* scriptObj.keyName can be used to access value associated with given key.<br> | |
* Example: | |
* <pre> | |
* <code> | |
* var x = java.lang.SystemProperties(); | |
* var y = jmap(x); | |
* println(y['java.class.path']); // prints java.class.path System property | |
* delete y['java.class.path']; // remove java.class.path System property | |
* </code> | |
* </pre> | |
* | |
* @param map java.util.Map instance that will be wrapped | |
* @constructor | |
*/ | |
function jmap(map) { | |
return new JSAdapter({ | |
__get__ : function(name) { | |
if (map.containsKey(name)) { | |
return map.get(name); | |
} else { | |
return undefined; | |
} | |
}, | |
__has__ : function(name) { | |
return map.containsKey(name); | |
}, | |
__delete__ : function (name) { | |
return map.remove(name); | |
}, | |
__put__ : function(name, value) { | |
map.put(name, value); | |
}, | |
__getIds__ : function() { | |
return map.keySet().toArray(); | |
}, | |
toString: function() { | |
return map.toString(); | |
} | |
}); | |
} | |
/** | |
* Creates a convenient script object to deal with java.util.List instances. | |
* The result script object behaves like an array. For example, | |
* scriptObj[index] syntax can be used to access values in the List instance. | |
* 'length' field gives size of the List. <br> | |
* | |
* Example: | |
* <pre> | |
* <code> | |
* var x = new java.util.ArrayList(4); | |
* x.add('Java'); | |
* x.add('JavaScript'); | |
* x.add('SQL'); | |
* x.add('XML'); | |
* | |
* var y = jlist(x); | |
* println(y[2]); // prints third element of list | |
* println(y.length); // prints size of the list | |
* | |
* @param map java.util.List instance that will be wrapped | |
* @constructor | |
*/ | |
function jlist(list) { | |
function isValid(index) { | |
return typeof(index) == 'number' && | |
index > -1 && index < list.size(); | |
} | |
return new JSAdapter({ | |
__get__ : function(name) { | |
if (isValid(name)) { | |
return list.get(name); | |
} else if (name == 'length') { | |
return list.size(); | |
} else { | |
return undefined; | |
} | |
}, | |
__has__ : function (name) { | |
return isValid(name) || name == 'length'; | |
}, | |
__delete__ : function(name) { | |
if (isValid(name)) { | |
list.remove(name); | |
} | |
}, | |
__put__ : function(name, value) { | |
if (isValid(name)) { | |
list.set(name, value); | |
} | |
}, | |
__getIds__: function() { | |
var res = new Array(list.size()); | |
for (var i = 0; i < res.length; i++) { | |
res[i] = i; | |
} | |
return res; | |
}, | |
toString: function() { | |
return list.toString(); | |
} | |
}); | |
} | |
/** | |
* This is java.lang.System properties wrapped by jmap. | |
* For eg. to access java.class.path property, you can use | |
* the syntax sysProps["java.class.path"] | |
*/ | |
var sysProps = jmap(java.lang.System.getProperties()); | |
// stdout, stderr & stdin | |
var out = java.lang.System.out; | |
var err = java.lang.System.err; | |
// can't use 'in' because it is a JavaScript keyword :-( | |
var inp = java.lang.System["in"]; | |
// useful imports for often used io, net classes | |
importPackage(java.io); | |
importPackage(java.net); | |
/** | |
* Generic any object to input stream mapper | |
* @param str input file name, URL or InputStream | |
* @return InputStream object | |
* @private | |
*/ | |
function inStream(str) { | |
if (typeof(str) == "string") { | |
// '-' means standard input | |
if (str == '-') { | |
return java.lang.System["in"]; | |
} | |
// try file first | |
var file = null; | |
try { | |
file = pathToFile(str); | |
} catch (e) { | |
} | |
if (file && file.exists()) { | |
return new FileInputStream(file); | |
} else { | |
try { | |
// treat the string as URL | |
return new URL(str).openStream(); | |
} catch (e) { | |
throw 'file or URL ' + str + ' not found'; | |
} | |
} | |
} else { | |
if (str instanceof InputStream) { | |
return str; | |
} else if (str instanceof URL) { | |
return str.openStream(); | |
} else if (str instanceof File) { | |
return new FileInputStream(str); | |
} | |
} | |
// everything failed, just give input stream | |
return java.lang.System["in"]; | |
} | |
/** | |
* Generic any object to output stream mapper | |
* | |
* @param out output file name or stream | |
* @return OutputStream object | |
* @private | |
*/ | |
function outStream(out) { | |
if (typeof(out) == "string") { | |
if (out == '>') { | |
return java.lang.System.out; | |
} else { | |
// treat it as file | |
return new FileOutputStream(pathToFile(out)); | |
} | |
} else { | |
if (out instanceof OutputStream) { | |
return out; | |
} else if (out instanceof File) { | |
return new FileOutputStream(out); | |
} | |
} | |
// everything failed, just return System.out | |
return java.lang.System.out; | |
} | |
/** | |
* stream close takes care not to close stdin, out & err. | |
* @private | |
*/ | |
function streamClose(stream) { | |
if (stream) { | |
if (stream != java.lang.System["in"] && | |
stream != java.lang.System.out && | |
stream != java.lang.System.err) { | |
try { | |
stream.close(); | |
} catch (e) { | |
println(e); | |
} | |
} | |
} | |
} | |
/** | |
* Loads and evaluates JavaScript code from a stream or file or URL<br> | |
* | |
* Examples: | |
* <pre> | |
* <code> | |
* load('test.js'); // load script file 'test.js' | |
* load('http://java.sun.com/foo.js'); // load from a URL | |
* </code> | |
* </pre> | |
* | |
* @param str input from which script is loaded and evaluated | |
*/ | |
function load(str) { | |
var stream = inStream(str); | |
var bstream = new BufferedInputStream(stream); | |
var reader = new BufferedReader(new InputStreamReader(bstream)); | |
var oldFilename = engine.get(engine.FILENAME); | |
engine.put(engine.FILENAME, str); | |
try { | |
engine.eval(reader); | |
} finally { | |
engine.put(engine.FILENAME, oldFilename); | |
} | |
streamClose(stream); | |
} | |
// file system utilities | |
/** | |
* Creates a Java byte[] of given length | |
* @param len size of the array to create | |
* @private | |
*/ | |
function javaByteArray(len) { | |
return java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, len); | |
} | |
var curDir = new File('.'); | |
/** | |
* Print present working directory | |
*/ | |
function pwd() { | |
println(curDir.getAbsolutePath()); | |
} | |
/** | |
* Changes present working directory to given directory | |
* @param target directory to change to. optional, defaults to user's HOME | |
*/ | |
function cd(target) { | |
if (target == undefined) { | |
target = sysProps["user.home"]; | |
} | |
if (!(target instanceof File)) { | |
target = pathToFile(target); | |
} | |
if (target.exists() && target.isDirectory()) { | |
curDir = target; | |
} else { | |
println(target + " is not a directory"); | |
} | |
} | |
/** | |
* Converts path to java.io.File taking care of shell present working dir | |
* | |
* @param pathname file path to be converted | |
* @private | |
*/ | |
function pathToFile(pathname) { | |
var tmp = pathname; | |
if (!(tmp instanceof File)) { | |
tmp = new File(tmp); | |
} | |
if (!tmp.isAbsolute()) { | |
return new File(curDir, pathname); | |
} else { | |
return tmp; | |
} | |
} | |
/** | |
* Copies a file or URL or stream to another file or stream | |
* | |
* @param from input file or URL or stream | |
* @param to output stream or file | |
*/ | |
function cp(from, to) { | |
if (from == to) { | |
println("file " + from + " cannot be copied onto itself!"); | |
return; | |
} | |
var inp = inStream(from); | |
var out = outStream(to); | |
var binp = new BufferedInputStream(inp); | |
var bout = new BufferedOutputStream(out); | |
var buff = javaByteArray(1024); | |
var len; | |
while ((len = binp.read(buff)) > 0 ) | |
bout.write(buff, 0, len); | |
bout.flush(); | |
streamClose(inp); | |
streamClose(out); | |
} | |
/** | |
* Shows the content of a file or URL or any InputStream<br> | |
* Examples: | |
* <pre> | |
* <code> | |
* cat('test.txt'); // show test.txt file contents | |
* cat('http://java.net'); // show the contents from the URL http://java.net | |
* </code> | |
* </pre> | |
* @param obj input to show | |
* @param pattern optional. show only the lines matching the pattern | |
*/ | |
function cat(obj, pattern) { | |
if (obj instanceof File && obj.isDirectory()) { | |
ls(obj); | |
return; | |
} | |
var inp = null; | |
if (!(obj instanceof Reader)) { | |
inp = inStream(obj); | |
obj = new BufferedReader(new InputStreamReader(inp)); | |
} | |
var line; | |
if (pattern) { | |
var count = 1; | |
while ((line=obj.readLine()) != null) { | |
if (line.match(pattern)) { | |
println(count + "\t: " + line); | |
} | |
count++; | |
} | |
} else { | |
while ((line=obj.readLine()) != null) { | |
println(line); | |
} | |
} | |
} | |
/** | |
* Returns directory part of a filename | |
* | |
* @param pathname input path name | |
* @return directory part of the given file name | |
*/ | |
function dirname(pathname) { | |
var dirName = "."; | |
// Normalize '/' to local file separator before work. | |
var i = pathname.replace('/', File.separatorChar ).lastIndexOf( | |
File.separator ); | |
if ( i != -1 ) | |
dirName = pathname.substring(0, i); | |
return dirName; | |
} | |
/** | |
* Creates a new dir of given name | |
* | |
* @param dir name of the new directory | |
*/ | |
function mkdir(dir) { | |
var dir = pathToFile(dir); | |
println(dir.mkdir()? "created" : "can not create dir"); | |
} | |
/** | |
* Creates the directory named by given pathname, including | |
* any necessary but nonexistent parent directories. | |
* | |
* @param dir input path name | |
*/ | |
function mkdirs(dir) { | |
var dir = pathToFile(dir); | |
println(dir.mkdirs()? "created" : "can not create dirs"); | |
} | |
/** | |
* Removes a given file | |
* | |
* @param pathname name of the file | |
*/ | |
function rm(pathname) { | |
file = pathToFile(pathname); | |
if (!file.exists()) { | |
println("file not found: " + pathname); | |
return false; | |
} | |
// note that delete is a keyword in JavaScript! | |
println(file["delete"]()? "deleted" : "can not delete"); | |
} | |
/** | |
* Removes a given directory | |
* | |
* @param pathname name of the directory | |
*/ | |
function rmdir(pathname) { | |
rm(pathname); | |
} | |
/** | |
* Synonym for 'rm' | |
*/ | |
function del(pathname) { | |
rm(pathname); | |
} | |
/** | |
* Moves a file to another | |
* | |
* @param from original name of the file | |
* @param to new name for the file | |
*/ | |
function mv(from, to) { | |
println(pathToFile(from).renameTo(pathToFile(to))? | |
"moved" : "can not move"); | |
} | |
/** | |
* Synonym for 'mv'. | |
*/ | |
function ren(from, to) { | |
mv(from, to); | |
} | |
var months = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]; | |
/** | |
* Helper function called by ls | |
* @private | |
*/ | |
function printFile(f) { | |
var sb = new java.lang.StringBuffer(); | |
sb.append(f.isDirectory()? "d" : "-"); | |
sb.append(f.canRead() ? "r": "-" ); | |
sb.append(f.canWrite() ? "w": "-" ); | |
sb.append(" "); | |
var d = new java.util.Date(f.lastModified()); | |
var c = new java.util.GregorianCalendar(); | |
c.setTime(d); | |
var day = c.get(java.util.Calendar.DAY_OF_MONTH); | |
sb.append(months[c.get(java.util.Calendar.MONTH)] | |
+ " " + day ); | |
if (day < 10) { | |
sb.append(" "); | |
} | |
// to get fixed length 'length' field | |
var fieldlen = 8; | |
var len = new java.lang.StringBuffer(); | |
for(var j=0; j<fieldlen; j++) | |
len.append(" "); | |
len.insert(0, java.lang.Long.toString(f.length())); | |
len.setLength(fieldlen); | |
// move the spaces to the front | |
var si = len.toString().indexOf(" "); | |
if ( si != -1 ) { | |
var pad = len.toString().substring(si); | |
len.setLength(si); | |
len.insert(0, pad); | |
} | |
sb.append(len.toString()); | |
sb.append(" "); | |
sb.append(f.getName()); | |
if (f.isDirectory()) { | |
sb.append('/'); | |
} | |
println(sb.toString()); | |
} | |
/** | |
* Lists the files in a directory | |
* | |
* @param dir directory from which to list the files. optional, default to pwd | |
* @param filter pattern to filter the files listed. optional, default is '.'. | |
*/ | |
function ls(dir, filter) { | |
if (dir) { | |
dir = pathToFile(dir); | |
} else { | |
dir = curDir; | |
} | |
if (dir.isDirectory()) { | |
var files = dir.listFiles(); | |
for (var i in files) { | |
var f = files[i]; | |
if (filter) { | |
if(!f.getName().match(filter)) { | |
continue; | |
} | |
} | |
printFile(f); | |
} | |
} else { | |
printFile(dir); | |
} | |
} | |
/** | |
* Synonym for 'ls'. | |
*/ | |
function dir(d, filter) { | |
ls(d, filter); | |
} | |
/** | |
* Unix-like grep, but accepts JavaScript regex patterns | |
* | |
* @param pattern to search in files | |
* @param files one or more files | |
*/ | |
function grep(pattern, files /*, one or more files */) { | |
if (arguments.length < 2) return; | |
for (var i = 1; i < arguments.length; i++) { | |
println(arguments[i] + ":"); | |
cat(arguments[i], pattern); | |
} | |
} | |
/** | |
* Find in files. Calls arbitrary callback function | |
* for each matching file.<br> | |
* | |
* Examples: | |
* <pre> | |
* <code> | |
* find('.') | |
* find('.', '.*\.class', rm); // remove all .class files | |
* find('.', '.*\.java'); // print fullpath of each .java file | |
* find('.', '.*\.java', cat); // print all .java files | |
* </code> | |
* </pre> | |
* | |
* @param dir directory to search files | |
* @param pattern to search in the files | |
* @param callback function to call for matching files | |
*/ | |
function find(dir, pattern, callback) { | |
dir = pathToFile(dir); | |
if (!callback) callback = print; | |
var files = dir.listFiles(); | |
for (var f in files) { | |
var file = files[f]; | |
if (file.isDirectory()) { | |
find(file, pattern, callback); | |
} else { | |
if (pattern) { | |
if (file.getName().match(pattern)) { | |
callback(file); | |
} | |
} else { | |
callback(file); | |
} | |
} | |
} | |
} | |
// process utilities | |
/** | |
* Exec's a child process, waits for completion & returns exit code | |
* | |
* @param cmd command to execute in child process | |
*/ | |
function exec(cmd) { | |
var process = java.lang.Runtime.getRuntime().exec(cmd); | |
var inp = new DataInputStream(process.getInputStream()); | |
var line = null; | |
while ((line = inp.readLine()) != null) { | |
println(line); | |
} | |
process.waitFor(); | |
$exit = process.exitValue(); | |
} | |
/** | |
* Exit the shell program. | |
* | |
* @param exitCode integer code returned to OS shell. | |
* optional, defaults to 0 | |
*/ | |
function exit(code) { | |
if (code) { | |
java.lang.System.exit(code + 0); | |
} else { | |
java.lang.System.exit(0); | |
} | |
} | |
/** | |
* synonym for exit | |
*/ | |
function quit(code) { | |
exit(code); | |
} | |
// XML utilities | |
/** | |
* Converts input to DOM Document object | |
* | |
* @param inp file or reader. optional, without this param, | |
* this function returns a new DOM Document. | |
* @return returns a DOM Document object | |
*/ | |
function XMLDocument(inp) { | |
var factory = javax.xml.parsers.DocumentBuilderFactory.newInstance(); | |
var builder = factory.newDocumentBuilder(); | |
if (inp) { | |
if (typeof(inp) == "string") { | |
return builder.parse(pathToFile(inp)); | |
} else { | |
return builder.parse(inp); | |
} | |
} else { | |
return builder.newDocument(); | |
} | |
} | |
/** | |
* Converts arbitrary stream, file, URL to XMLSource | |
* | |
* @param inp input stream or file or URL | |
* @return XMLSource object | |
*/ | |
function XMLSource(inp) { | |
if (inp instanceof javax.xml.transform.Source) { | |
return inp; | |
} else if (inp instanceof Packages.org.w3c.dom.Document) { | |
return new javax.xml.transform.dom.DOMSource(inp); | |
} else { | |
inp = new BufferedInputStream(inStream(inp)); | |
return new javax.xml.transform.stream.StreamSource(inp); | |
} | |
} | |
/** | |
* Converts arbitrary stream, file to XMLResult | |
* | |
* @param inp output stream or file | |
* @return XMLResult object | |
*/ | |
function XMLResult(out) { | |
if (out instanceof javax.xml.transform.Result) { | |
return out; | |
} else if (out instanceof Packages.org.w3c.dom.Document) { | |
return new javax.xml.transform.dom.DOMResult(out); | |
} else { | |
out = new BufferedOutputStream(outStream(out)); | |
return new javax.xml.transform.stream.StreamResult(out); | |
} | |
} | |
/** | |
* Perform XSLT transform | |
* | |
* @param inp Input XML to transform (URL, File or InputStream) | |
* @param style XSL Stylesheet to be used (URL, File or InputStream). optional. | |
* @param out Output XML (File or OutputStream | |
*/ | |
function XSLTransform(inp, style, out) { | |
switch (arguments.length) { | |
case 2: | |
inp = arguments[0]; | |
out = arguments[1]; | |
break; | |
case 3: | |
inp = arguments[0]; | |
style = arguments[1]; | |
out = arguments[2]; | |
break; | |
default: | |
println("XSL tranform requires 2 or 3 arguments"); | |
return; | |
} | |
var factory = javax.xml.transform.TransformerFactory.newInstance(); | |
var tranformer; | |
if (style) { | |
transformer = factory.newTransformer(XMLSource(style)); | |
} else { | |
transformer = factory.newTransformer(); | |
} | |
var source = XMLSource(inp); | |
var result = XMLResult(out); | |
transformer.transform(source, result); | |
if (source.getInputStream) { | |
streamClose(source.getInputStream()); | |
} | |
if (result.getOutputStream) { | |
streamClose(result.getOutputStream()); | |
} | |
} | |
// miscellaneous utilities | |
/** | |
* Prints which command is selected from PATH | |
* | |
* @param cmd name of the command searched from PATH | |
*/ | |
function which(cmd) { | |
var st = new java.util.StringTokenizer(env.PATH, File.pathSeparator); | |
while (st.hasMoreTokens()) { | |
var file = new File(st.nextToken(), cmd); | |
if (file.exists()) { | |
println(file.getAbsolutePath()); | |
return; | |
} | |
} | |
} | |
/** | |
* Prints IP addresses of given domain name | |
* | |
* @param name domain name | |
*/ | |
function ip(name) { | |
var addrs = InetAddress.getAllByName(name); | |
for (var i in addrs) { | |
println(addrs[i]); | |
} | |
} | |
/** | |
* Prints current date in current locale | |
*/ | |
function date() { | |
println(new Date().toLocaleString()); | |
} | |
/** | |
* Echoes the given string arguments | |
*/ | |
function echo(x) { | |
for (var i = 0; i < arguments.length; i++) { | |
println(arguments[i]); | |
} | |
} | |
/** | |
* This is C-like printf | |
* | |
* @param format string to format the rest of the print items | |
* @param args variadic argument list | |
*/ | |
function printf(format, args/*, more args*/) { | |
var array = java.lang.reflect.Array.newInstance(java.lang.Object, | |
arguments.length - 1); | |
for (var i = 0; i < array.length; i++) { | |
array[i] = arguments[i+1]; | |
} | |
return java.lang.System.out.printf(format, array); | |
} | |
/** | |
* Reads one or more lines from stdin after printing prompt | |
* | |
* @param prompt optional, default is '>' | |
* @param multiline to tell whether to read single line or multiple lines | |
*/ | |
function read(prompt, multiline) { | |
if (!prompt) { | |
prompt = '>'; | |
} | |
var inp = java.lang.System["in"]; | |
var reader = new BufferedReader(new InputStreamReader(inp)); | |
if (multiline) { | |
var line = ''; | |
while (true) { | |
java.lang.System.err.print(prompt); | |
java.lang.System.err.flush(); | |
var tmp = reader.readLine(); | |
if (tmp == '' || tmp == null) break; | |
line += tmp + '\n'; | |
} | |
return line; | |
} else { | |
java.lang.System.err.print(prompt); | |
java.lang.System.err.flush(); | |
return reader.readLine(); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
ts.agg = function(name) { }; | |
ts.ds = function(name, timeRange) { }; | |
ts.div = function(tsArray) { }; | |
ts.mult = function(tsArray) { }; | |
ts.avgAbove = function(tsArray, N) { }; | |
/* | |
::-------------------------------------------------------------------------:: | |
Specifying one or more time series. | |
::-------------------------------------------------------------------------:: | |
*/ | |
// A single series | |
ts("kafka.my_topic.errors.count"); | |
// Multiple series by wildcard. | |
ts("kafka.my_topic.*.count"); | |
// Multiple series by regex. | |
ts("/kafka.my_topic.(\d+).count/"); | |
// Multiple series via parameters. | |
ts("kafka.my_topic.errors.count", "kafka.my_topic.messages.count"); | |
/* | |
::-------------------------------------------------------------------------:: | |
Specifying aggregate functions and downsampling. | |
::-------------------------------------------------------------------------:: | |
*/ | |
// Aggregate by summing | |
ts("kafka.my_topic.messages.count").agg("sum"); | |
// Same as above but uses shortcut syntax. | |
ts("sum:kafka.my_topic.messages.count"); | |
// Valid. The call to agg() takes precedence. | |
ts("sum:kafka.my_topic.messages.count").agg("avg"); | |
// Downsample, 1 minute average. | |
ts("kafka.my_topic.messages.count").ds("avg", "1min"); | |
// Same, using shortcut. | |
ts(":avg-1min:kafka.my_topic.messages.count"); | |
// Altogether. | |
ts("sum:avg-1min:kafka.my_topic.messages.count"); | |
ts("kafka.my_topic.messages.count").agg("sum").ds("avg", "1min"); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment