{"id":22812654,"url":"https://github.com/nastel/jkool-client-java-api","last_synced_at":"2026-02-27T15:44:28.867Z","repository":{"id":34501885,"uuid":"38442743","full_name":"Nastel/jkool-client-java-api","owner":"Nastel","description":"JKQL Streaming \u0026 Query API Using REST (HTTPS, WebSockets)","archived":false,"fork":false,"pushed_at":"2025-04-14T04:55:44.000Z","size":5322,"stargazers_count":5,"open_issues_count":0,"forks_count":1,"subscribers_count":15,"default_branch":"master","last_synced_at":"2025-04-22T16:19:52.545Z","etag":null,"topics":["jkool","jkool-cloud","jkool-streams","query-jkool","rest-api","websockets"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Nastel.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2015-07-02T16:07:05.000Z","updated_at":"2025-04-14T04:55:39.000Z","dependencies_parsed_at":"2024-03-25T15:47:34.229Z","dependency_job_id":"68ad208a-8d24-4d11-b8e8-58597efb6acc","html_url":"https://github.com/Nastel/jkool-client-java-api","commit_stats":null,"previous_names":[],"tags_count":22,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nastel%2Fjkool-client-java-api","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nastel%2Fjkool-client-java-api/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nastel%2Fjkool-client-java-api/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Nastel%2Fjkool-client-java-api/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Nastel","download_url":"https://codeload.github.com/Nastel/jkool-client-java-api/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":250275553,"owners_count":21403680,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["jkool","jkool-cloud","jkool-streams","query-jkool","rest-api","websockets"],"created_at":"2024-12-12T12:13:22.659Z","updated_at":"2026-02-27T15:44:28.802Z","avatar_url":"https://github.com/Nastel.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# JKQL Streaming \u0026 Query API Using REST\n\n-----------------------\n\n**NOTE:** `jkool-client-api` version `0.5.0` migrated to Java 11.\n\nLatest Java 8 compliant `jkool-client-api` version is `0.4.x`.\n\n-----------------------\n\n**NOTE:** `jkool-client-api` version `0.3.3` migrated from `javax.ws.rs` (Java EE) to `jakarta.ws.rs` (Jakarta EE) API.\n\nLatest Java EE compliant `jkool-client-api` version is `0.3.2.x`.\n\n-----------------------\n\nJKQL Streaming \u0026 Query API allows you to send events, metrics, transactions to and run queries against your data repository. You will need\n\"access token\" with streaming permission to store data and \"access token\" with query permission to run queries. Tokens are associated with\nyour repository and user profile. The API uses HTTP(s) and WebSockets protocols and responses are JSON.\n\nOther language bindings can be generated with the Swagger Code Generator using the Swagger yaml file found it the \"swagger\" folder.\n\nPlease be aware the Swagger yaml file is documenting every field that can be passed via Restful API. When using this Java Helper API,\nmany fields will have default values.\n\n## Concepts and Terminology\n\nYou can find more info in [jKool Streaming Guide](https://www.meshiq.com/download/jkool-model.pdf). JKQL streaming supports the\nfollowing data collection types:\n\n| Type | Description |\n|------|-------------|\n|Event|basic time series element containing time, message, severity and other fields associated with event|\n|Activity|a group of events and other activities (e.g. transactions)|\n|Snapshot|categorized collection of properties (name, value, type) at a \"point in time\"|\n|Dataset|user defined set of data elements with user defined columns|\n|Property|name, value pair. Properties can be associated with events, activities and snapshots|\n\nThis Git repository contains a Swagger yaml file. Open this file in a Swagger Editor and you will have detailed documentation of each field\nthat comprises the above-mentioned data.\n\n## How to build\n\nTo use this sample code please do one of the following:\n\n* Build this project on your own by using these Maven build configurations:\n    * To build the project, run Maven goals `clean package`\n    * To build the project and install to local repo, run Maven goals `clean install`\n    * To make distributable release assemblies use one of profiles: `pack-assembly` or `pack-assembly-src_doc`:\n        * containing only binary (including `test` package) distribution: run `mvn -P pack-assembly`\n        * containing binary (including `test` package), `source` and `javadoc` distribution: run `mvn -P pack-assembly-src_doc`\n    * To make Maven required `source` and `javadoc` packages, use profile `pack-sources-and-javadocs`\n    * To make Maven central compliant release having `source`, `javadoc` and all signed packages, use `final-release` profile\n\n  Release assemblies are built to `/build` directory.\n* Add the following into your Maven pom file:\n\n```pom\n    \u003cdependency\u003e\n        \u003cgroupId\u003ecom.jkoolcloud.client.api\u003c/groupId\u003e\n        \u003cartifactId\u003ejkool-client-api\u003c/artifactId\u003e\n        \u003cversion\u003e0.5.0\u003c/version\u003e\n    \u003c/dependency\u003e\n```\n\n## Streaming over HTTPS\n\nStreaming allows developers to send time series data such as events, metrics, transactions, logs using JSON/HTTPS. You will need your access\ntoken with streaming permission. This token ensures that the streaming data goes to the repository associated with the access token.\n\n```java\n    JKStream jkSend = new JKStream(\"yourtoken\");\n```\n\nCreate an event and populate the fields you wish to stream. For example:\n\n```java\n    Event event = new Event(\"Casablanca\");\n    event.setAppl(\"WebOrders\").setServer(InetAddress.getLocalHost().getHostName())\n            .setNetAddr(InetAddress.getLocalHost().getHostAddress()).setDataCenter(\"DCNY\")\n            .setElapsedTimeUsec(TimeUnit.HOURS.toMicros(2)).setLocation(\"New York, NY\")\n            .setMsgText(\"Casablanca is playing.\");\n```\n\nPlease note that this example code depicts streaming in real-time. Therefore, the start date of the event will default to the current\ndate/time and the end date will default to the start date plus the elapsed time. You can however control start/end dates. For example:\n\n```java\n    event.setTime(System.currentTimeMillis()).setElapsedTimeUsec(TimeUnit.HOURS.toMicros(2));\n```\n\nOptionally add any user defined properties using `Property` class:\n\n```java\n    Property customerName = new Property(\"Name\", \"John Smith\");\n    Property customerAge = new Property(\"Age\", 26, ValueType.VALUE_TYPE_AGE_YEAR);\n    Property customerTemp = new Property(\"Temp\", 98.6, ValueType.VALUE_TYPE_TEMP_F);\n    event.addProperty(customerName, customerAge, customerTemp);\n```\n\nProperties can be grouped and categorized using `Snapshot` class:\n\n```java\n    // create a categorized snapshot (envelope)\n    Snapshot customer = new Snapshot(\"CustomerData\", \"General\");\n    Property customerName = new Property(\"Name\", \"John Smith\");\n    Property customerAge = new Property(\"Age\", 26, ValueType.VALUE_TYPE_AGE_YEAR);\n    Property customerTemp = new Property(\"Temp\", 98.6, ValueType.VALUE_TYPE_TEMP_F);\n    customer.addProperty(customerName, customerAge, customerTemp);\n    // add snapshot to event\n    event.addSnapshot(customer);\n```\n\nFinally, invoke the post method on the `JKStream` object, passing it the event you wish to stream:\n\n```java\n    JKStream jkSend = new JKStream(\"yourtoken\");\n    Event event = new Event(\"Casablanca\");\n    event.setAppl(\"WebOrders\").setServer(InetAddress.getLocalHost().getHostName())\n        .setNetAddr(InetAddress.getLocalHost().getHostAddress()).setDataCenter(\"DCNY\")\n        .setElapsedTimeUsec(TimeUnit.HOURS.toMicros(2)).setLocation(\"New York, NY\")\n        .setMsgText(\"Casablanca is playing.\");\n\n    // create custom properties\n    Property customerName = new Property(\"Name\", \"John Smith\");\n    Property customerAge = new Property(\"Age\", 26, ValueType.VALUE_TYPE_AGE_YEAR);\n    Property customerTemp = new Property(\"Temp\", 98.6, ValueType.VALUE_TYPE_TEMP_F);\n\n    event.addProperty(customerName, customerAge, customerTemp);\n    Response response = jkSend.post(event);\n    response.close();\n```\n\nThe `JKStream` formats the `event` into JSON and sends it to https://stream.meshiq.com.\n\n### Running JKQL (Synchronously)\n\nIn addition to streaming, data can also be retrieved from jKool via Rest. To do this, make use of the jKool Query Language (JKQL). Please\nsee [JKQL Reference Guide](https://www.nastel.com/wp-content/uploads/2020/03/Nastel_jKQL_User_Guide.pdf). Use the `JKQuery` to run JKQL\nsynchronously. Use your access token along with the JKQL query. Below is an example:\n\n```java\n    JKQuery jkQuery = new JKQuery(\"yourtoken\");\n    Response response = jkQuery.call(\"get number of events for today\");\n    Map\u003cString, Object\u003e jsonResponse = response.readEntity(Map.class);\n    response.close();\n```\n\nAll returned JKQL responses are JSON.\n\n### Running JKQL (Asynchronously)\n\nDevelopers can also invoke JKQL queries asynchronously using callbacks. To do this, make use of the `JKQueryAsync`. Below is an example.\nThis example makes use of two connection handlers: 1) for tracing connection events and 2) for retrying connection during failures.\n\n```java\n    // setup WebSocket connection and connect\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    // retry connection handler\n    jkQuery.addConnectionHandler(new JKRetryConnectionHandler(5000, TimeUnit.MILLISECONDS));\n    // trace connection handler\n    jkQuery.addConnectionHandler(new JKTraceConnectionHandler(System.out, true));\n    ...\n    jkQuery.connect();\n```\n\nThe next step is to set up default callback handlers (optional but recommended). Default callback handlers are called for responses not\nassociated with any specific query or subscription.\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    // setup a default response handler for responses not associated with any specific query\n    jkQuery.addDefaultCallbackHandler(new JKTraceQueryCallback(System.out, true));\n    jkQuery.connect(); // connect stream with WebSocket interface\n```\n\nNext execute your query. All response will be delegated to all default callback handlers, because no callback has been associated with this\nquery:\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    // run query in async mode without a callback (use default response handlers)\n    jkQuery.callAsync(\"get number of events for today\");\n    ...\n    jkQuery.close(); // close connection\n```\n\nAlternatively you can execute a query with a specific callback instance. All responses associated with this query will be routed to the\ncallback instance specified in the `JKQueryAsync.callAsync(...)` call.\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    // run query in async mode with a specific callback\n    JKStatementAsync query = jkQuery.callAsync(\"get events\", new MyJKQueryCallback());\n    query.awaitOnDone(10000, TimeUnit.MILLISECONDS); // optional wait 10s for query to finish\n    ...\n    query.close(); // close query statement\n    jkQuery.close(); // close connection\n```\n\n`MyJKQueryCallback.onResponse()` is called when for every response to the query -- there maybe one or more responses depending on the query.\n`MyJKQueryCallback.onClose()` is called when the handle is closed due to `JKStatementAsync.close()`.\n`MyJKQueryCallback.onDone()` is called when the handle will never be called again. This happens when the query is cancelled using\n`JKQueryAsync.cancelAsync()` call or when all responses associated with a specific query have been delivered.\n\n```java\npublic class MyJKQueryCallback implements JKQueryCallback {\n    @Override\n    public void onResponse(JKStatementAsync qHandle, JsonObject response, Throwable ex) {\n        System.out.println(\"response: handle=\" + qHandle + \", response=\" + response);\n        if (ex != null) {\n            System.out.println(\"error: handle=\" + qHandle + \", error=\" + ex);\n        }\n    }\n\n    @Override\n    public void onClose(JKStatementAsync qHandle) {\n        if (trace) {\n            out.println(\"Closed handle=\" + qHandle);\n        }\n    }\n\n    @Override\n    public void onDone(JKStatementAsync qHandle) {\n        if (trace) {\n            out.println(\"Done handle=\" + qHandle);\n        }\n    }\n}\n```\n\n`jkQueryAsync.callAsync()` returns a query statement (instance of `JKStatementAsync`), which can be used later to cancel subscriptions.\nCancelling an active query subscription attempts to stop any streaming traffic associated with a specific subscription. Cancellation is also\nissued asynchronously and any responses that are still in transit will be routed to the default response handler specified\nby `addDefaultCallbackHandler()` call.\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    // run query in async mode with a callback\n    JKStatementAsync qhandle = jkQuery.callAsync(\"get number of events for today\", new MyJKQueryCallback());\n    ...\n    // attempt to cancel subscription to the query results\n    qhandle.cancelAsync(qhandle);\n```\n\nJKQL queries can also be executed using prepared JKQL statements as follows:\n\n```java\n   JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n   JKStatementAsync query = jkQuery.prepare(\"get number of events for today\", new MyJKQueryCallback());\n   query.callAsync(100); // call with specified max rows for responses\n   query.awaitOnDone(10000, TimeUnit.MILLISECONDS); // wait for completion for 10 seconds\n```\n\n### Connection Event Handling\n\nConnection handlers can be used to intercept and handle WebSocket connection events such as open, close, error:\n\n```java\npublic class MyConnectionHandler implements JKConnectionHandler {\n    @Override\n    public void error(JKQueryAsync async, Throwable ex) {\n        System.err.println(\"error: \" + async + \", error=\" + ex);\n        ex.printStackTrace();\n    }\n\n    @Override\n    public void close(JKQueryAsync async, CloseReason reason) {\n        System.out.println(\"close: \" + async + \", reason=\" + reason);\n    }\n\n    @Override\n    public void open(JKQueryAsync async) {\n        System.out.println(\"open: \" + async);\n    }\n}\n```\n\nConnection handlers can be associated with a JKQL connection handle `JKQueryAsync` as follows:\n\n```java\n    // setup jKool WebSocket connection and connect\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    jkQueryAsync.addConnectionHandler(new MyConnectionHandler());\n    ...\n    jkQueryAsync.connect();\n```\n\n### Subscribing to Real-time Event Streams\n\nDevelopers can also subscribe to live data streams using `JKQueryAsync` class. Subscriptions are based continuous queries submitted by the\nclient and run on the jKool servers. The results of the query are emitted as data becomes available and streamed back to the client call\nback handler instance of `JKQueryCallback`. See example below:\n\n```java\n    // setup WebSocket connection and connect\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    jkQuery.addConnectionHandler(new JKRetryConnectionHandler(5000, TimeUnit.MILLISECONDS));\n    jkQuery.addConnectionHandler(new MyConnectionHandler());\n\n    // setup a default response handler for responses not associated with any specific query\n    jkQuery.addDefaultCallbackHandler(new MyJKQueryCallback());\n    jkQuery.connect(); // connect stream with WebSocket interface\n\n    // run subscription query in async mode with a callback\n    JKStatementAsync qhandle = jkQuery.subAsync(\"events where severity \u003e 'INFO'\", new MyJKQueryCallback());\n    ...\n```\n\nThe code above is equivalent to the JKQL statement `subscribe to events where severity \u003e 'INFO'`. `MyJKQueryCallback()` gets called as the\nquery matches incoming streams. All pattern stream matching is done on the jKool server side. `subscribe` query runs on real-time streams\nonly and never on past data. Use `get` queries to get past data.\n\n### Running JKQL Searches on Message Content\n\n`JKQueryAsync` class provides a helper method to run pattern matches against event message content. See below:\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    ...\n    // run search query in async mode with a callback\n    JKStatementAsync qhandle = jkQuery.searchAsync(\"failure\", 10, new MyJKQueryCallback());\n    ...\n```\n\nThe code above is equivalent to the JKQL statement `get events where message contains \"failure\"`, where 10 is the maximum number of matching\nrows to return (default is 100). The example above can be implemented as:\n\n```java\n    JKQueryAsync jkQuery = new JKQueryAsync(\"yourtoken\");\n    ...\n    // run query in async mode with a callback\n    JKStatementAsync qhandle = jkQuery.callAsync(\"get events where message contains \\\"failure\\\"\", 10, new MyJKQueryCallback());\n    ...\n```\n\n### Running JKQL from Command Line\n\nYou can run JKQL from command line using a helper class `JKQLCmd` below. Run all commands from the root `jkool-client-api-\u003cversion\u003e`\ndirectory. `JKQLCmd` uses Secure WebSocket/JSON interface to run JKQL.\n\n```sh\n    java -cp ./*:./lib/* com.jkoolcloud.client.api.utils.JKQLCmd -token access-token -query \"get events\" -wait 30000\n```\n\nRunning message content searches:\n\n```sh\n    java -cp ./*:./lib/* com.jkoolcloud.client.api.utils.JKQLCmd -token access-token -search \"failure\" -wait 30000\n```\n\nCommand line arguments can be specified via a property file, where any command line argument overrides values specified in the property\nfile:\n\n```sh\n    java java -cp ./*:./lib/* com.jkoolcloud.client.api.utils.JKQLCmd -file cmd.properties -query \"get number of events for today\"\n```\n\nBelow is a sample property file containing `JKQLCmd` command line arguments (`token` should have your jKool API access token):\n\n```properties\ntoken=your-access-token\nuri=wss://xray.meshiq.com/jkool-service/jkqlasync\nquery=get number of events\ntrace=true\nwait=15000\nmaxrows=100\nretry=0\n#jpath=jk_response/rows-found\n```\n\n### Running JKQL using Curl\n\nREST can be used to retrieve data natively (without helper classes) out of your repository using `curl`. Note that you can specify your\ntoken in the HTTP header (`X-API-Key`) as well instead of specifying it as a query parameter (`jk_token`). Access tokens must have\n`query`/`read` permission, streaming tokens don't have query access by default.\n\nExample using `jk_token` parameter to pass access token:\n\n```sh\ncurl -i -d \"jk_token=access-token\u0026jk_query=get number of events\" -X POST https://xray.meshiq.com/jkool-service/jkql\n```\nExample using (`X-API-Key`) to pass access token: \n```sh\ncurl -i -H \"X-API-Key: Access-Token\" -d \"jk_query=get number of events\" -X POST https://xray.meshiq.com/jkool-service/jkql\n```\nBelow is a list of supported query parameters: \n\n| Parameter | Required | Default| Description |\n|-----------|----------|--------|-------------|\n|`jk_token`|Yes|None|API access token|\n|`jk_repo`|No|None|Repository to fetch data from (Required if token references none or multiple repositories)|\n|`jk_query`|Yes|None|query statement to run|\n|`jk_subid`|No|Auto|query request correlator (GUID)|\n|`jk_tz`|No|Server TZ|timezone to be used for timestamps|\n|`jk_locale`|No|Server Locale|locale to be used for date/time and number formats|\n|`jk_date`|No|today|date range for the query|\n|`jk_maxrows`|No|100|maximum rows to be fetched|\n|`jk_trace`|No|false|enable query trace during execution|\n|`jk_timeout`|No|60000|max query timeout in ms|\n|`jk_range`|No|None|query range for`find` queries only|\n|`jk_slow`|No|5000|Time in ms beyond which query is considered slow|\n\nBelow are common JSON response fields:\n\n| Field | Description |\n|-----------|---------|\n|`jk_call`|query call verb|\n|`jk_query`|query associated with the response|\n|`jk_ccode`|query response completion code|\n|`jk_error`|query error message if fails|\n|`jk_subid`|query correlator associated with the request|\n|`jk_elapsed_ms`|elapsed time to execute the query (ms)|\n\nExample of a failed response:\n\n```json\n{\n    \"jk_call\": \"get\",\n    \"jk_ccode\": \"ERROR\",\n    \"jk_elapsed_ms\": 8,\n    \"jk_subid\": \"f41194b0-5b09-4464-890b-36fd66c01738\",\n    \"jk_error\": \"com.nastel.jkool.jkql.admin.JKQLSecurityException: Undefined access token 'X', stmt: get number of logs\"\n}\n```\n\nExample of a successful response:\n\n```json\n{\n    \"rows-found\": 798,\n    \"row-count\": 1,\n    \"total-row-count\": 1,\n    \"data-date-range\": \"1590206401731372 TO 1590248453356930\",\n    \"query-date-filter\": \"1590206400000000 TO 1590292799999999\",\n    \"timezone\": \"Eastern Daylight Time\",\n    \"status\": \"SUCCESS\",\n    \"time\": 1590248630137306,\n    \"item-type\": \"Log\",\n    \"colhdr\": [\n        \"NumberOf\"\n    ],\n    \"coltype\": {\n        \"NumberOf\": \"INTEGER\"\n    },\n    \"collabel\": {\n        \"NumberOf\": \"NumberOf\"\n    },\n    \"rows\": [\n        {\n            \"NumberOf\": 798\n        }\n    ],\n    \"overallStatistics\": {\n        \"jkql_parse.time.usec\": 19,\n        \"jkql_statement.count\": 1,\n        \"json_string.time.usec\": 46,\n        \"raw_result_post_process.time.usec\": 0,\n        \"request_wait.time.usec\": 69,\n        \"rows_found.count\": 798,\n        \"rows_returned.count\": 1,\n        \"solr_request_build.time.usec\": 88,\n        \"solr_request_elapsed.time.usec\": 11000,\n        \"solr_request_exec.time.usec\": 11905,\n        \"solr_request_qtime.time.usec\": 0,\n        \"solr_result_proc.time.usec\": 12,\n        \"total_exec.time.usec\": 47707\n    }\n}\n```\n\n### Streaming with Curl\n\nData can be streamed using `curl`. Below is an example:\n\n```sh\ncurl -i -H \"Content-Type:application/json\" -H \"X-API-Key:YOURTOKEN\" -X POST https://stream.meshiq.com -d '{\"operation\":\"streamingwithcurl\",\"type\":\"EVENT\",\"start-time-usec\":1457524800000000,\"end-time-usec\":1457524800000000,\"msg-text\":\"Example curl streaming\",\"source-fqn\":\"APPL=TestingCurl#SERVER=CurlServer100#NETADDR=11.0.0.2#DATACENTER=DC1#GEOADDR=52.52437,13.41053\"}'\n```\n\n### Streaming with Python\n\nStreaming data using Python \"requests\" object. Below is an example:\n\n```python\nimport requests\nheaders = {'X-API-Key': 'YOURTOKEN'}\npayload={'operation':'streamingwithpython','type':'EVENT','start-time-usec':1457524800000000,'end-time-usec':1457524800000000,'msg-text':'Example Python Streaming','source-fqn':'APPL=TestingCurl#SERVER=CurlServer100#NETADDR=11.0.0.2#DATACENTER=DC1#GEOADDR=52.52437,13.41053'}\nresp = requests.post('https://stream.meshiq.com', headers=headers, json=payload)\n```\n\n### Note on Timestamps\n\nTimestamp fields such as `time-usec`, `start-time-usec` and `end-time-usec` are measured in microseconds (usec.), between the current time\nand midnight, January 1, 1970 UTC. Most language environments don't return such time in microsecond precision, in which case you would have\nto compute it by obtaining current time in milliseconds and convert to microseconds (e.g. `System.currentTimeMillis() * 1000`).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnastel%2Fjkool-client-java-api","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnastel%2Fjkool-client-java-api","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnastel%2Fjkool-client-java-api/lists"}