That matches all the colors in the KE light theme

👋 Hi,

We're making KQL queries (to Azure Resource Graph) from Javascript, and it would be great if we could get syntax highlighting for strings that contain Kusto, in at least Javascript, similar to something like this https://marketplace.visualstudio.com/items?itemName=derefs.vscode-inline-sql-highlight or https://github.com/Microsoft/typescript-styled-plugin

If I create a .kql document and put in the following code:

let BytesInMB=(bytes: long) {
   round(bytes / 1024.0 / 1024.0, 2)
};
print a=BytesInMB(42)
;

I'd like to see two things:

• Pressing Control-T presents an indexed view of all the symbols in the workspace. I should be able to search for 'Bytes' and navigate directly to BytesInMB, from any document I have open.
  • Currently, the Control-T simply shows No matching symbols in workspace
• The outline view for a document, the pane displayed below the Kusto Workspace in the "Explorer" view, should show BytesInMB as a symbol, along with any other variables/functions/tables defined in the document.
  • Currently, the outline view simply says No symbols found in document 'temp.kql'

https://code.visualstudio.com/api/working-with-extensions/bundling-extension

Currently, when I want to connect to a cluster I need to load it which means manually entering the cluster URL, authority id and database. Then we go to the microsoft login page.

Instead it would be useful if I could define in the settings some database and allow to extract their credentials from environment variables.
For example in the settings I would have something like:

"databases": [{
"database_id": "db1"
"database": "my_database1"
"cluster": "https://my_cluster.kusto.windows.net",
"authority_id": "${authority_id_env_var_for_cluster1}",
"client_id": "${client_id_env_var_for_cluster1}",
"client_secret": "${client_secret_env_var_for_cluster1}",
},{...}]

Then I would be able to give a command: load db1 and the connection would be configured where it gets the credentials from environment variables.

jq-action was missing multiline support, so I added it downstream here to use. I then contributed it back upstream in sergeysova/jq-action#3.

This issue tracks removing the downstream use in .github\actions\jq-action-master in favor of upstream sergeysova/jq-action, which can only be done once that PR merges and a new version is released.

e.g.

.alter table FooBar policy retention "{\"SoftDeletePeriod\":\"180.00:00:00\",\"Recoverability\":\"disabled\"}"

Not sure if it is a bug or new feature request, but the comment out shortcut (Ctrl+/) does not work for Kusto syntax (it does not add // at the beggining of the line).

I love the package btw.

Hi Ross,

I am looking for ways to add Kusto support to Emacs and I was wondering if you are willing to bundle the LSP server as a standalone NPM package. This will help me leverage lsp-mode in Emacs.

Thanks.

The KustoCodeService chunks up a document in sometimes strange ways, which leads to odd document formatting. See JANK_CLEANUP.md for a couple examples of this.

The idea here would be to do a pre-formatting step where newlines are added or removed in certain places before passing the text on to the KustoCodeService, in a way so that the code service chunks it into blocks more logically.

For example,

• when the document is a .create-or-alter statement
  • removing blank lines between the .create-or-alter command and the function name, or blank lines between the function name and the opening {.
  • adding a blank line between the opening { and the first query block
  • adding a blank line between the closing } and the preceding block
• when the document has multiple blocks separated by semi-colons
  • adding a blank line after each semi-colon

Azure Data Studio supports connecting to Data Explorer and Log Analytics Workspaces (but VS Code doesn't, AFAICT). It would be useful to have these extensions in Azure Data Studio too.

Things like

.alter table
.create-merge table
.set-or-replace async
.ingest into table
.drop table ... ifexists

etc

Right now, there's a device code auth flow for every single kusto.execute() call. It would open up some use cases if we could make many kusto calls without each of them requiring a login (table schema fetching, detailed function metadata fetching).

This is probably a feature request to the azure-kusto-node library (or a contribution to it).

When trying to load symbols from a cluster I get the following error:

/home/pearj/.vscode-server/extensions/rosshamish.kuskus-kusto-language-server-1.0.35/server/node_modules/azure-kusto-data/dist-esm/src/client.js:226
            const clientTimeout = properties.getClientTimeout();
                                             ^

TypeError: properties.getClientTimeout is not a function
    at KustoClient._getClientTimeout (/home/pearj/.vscode-server/extensions/rosshamish.kuskus-kusto-language-server-1.0.35/server/node_modules/azure-kusto-data/dist-esm/src/client.js:226:46)
    at KustoClient._execute (/home/pearj/.vscode-server/extensions/rosshamish.kuskus-kusto-language-server-1.0.35/server/node_modules/azure-kusto-data/dist-esm/src/client.js:113:30)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)

Node.js v18.15.0
[Info  - 12:34:35 PM] Connection to server got closed. Server will restart.

Any idea what is causing this? I'm running vscode 1.84.2 inside WSL2

The first snippet should be

.create-or-alter function with (folder="", docstring="", skipvalidation="false")
FunctionName(param1: int, param2: string)
{

    // query

}

When I am selecting the kuskus pack from ctrl+shift+P its resulting this error.

Setting a Jupyter notebook cell's language to Kusto (this extension) causes the cell to fail to lint. Please extend this extension's linting to Jupyter cells / embedded KQL contexts.

Here is with the current version of the extension :

And with the base fork (Azure Log Analytics (Kusto) Syntax Highlighting) :

With one extension, almost nothing is supported, with another the keyword has is not supported.

With the following code, hovering over any keyword results in a tooltip Cannot read properties of undefined (reading: 'IsOptional')

.create-or-alter function 
BytesInMB(bytes: long) {
   round(bytes / 1024.0 / 1024.0, 2)
}

It doesn't seem to matter what's in the function body. In fact, it seems to happen with any dot commands (e.g. .show table).

Changing the function above to use let BytesInMB=() syntax, the tooltips work correctly.

We don't want to dupe functionality from Kusto Explorer / Kusto Web Explorer though, so probably the best route here is to generate a link to kusto web explorer with the query text url encoded, then use open() to open it in the browser. Shell out to web explorer, which already implements all this. Folks can bounce back and forth between the web explorer (for execution) and vs code (for source control).

Best part of this would be that the web explorer and vs code's editor capabilities are based on the same npm module(s), so the editing experience should/would be exactly the same. Consistency!

Hi,
Installed the Kuskus pack, but I don't get the syntax highlighting I expect and can't fin any information on what I should do to make it work.
/Per

Hi I have loaded the symbols from help.windows.core.net/common/samples page into visual studio code editor.
But still I can see the issues with the symbols.

Requires #3 probably, since we'd need to make a kusto call per-table to get each table's schema, and doing a login for every table is a no-go.

Kuskus markdown syntax highlighting messes up markdown highlighting even outside the code block.

Sample markdown code

# Test

## First query

```kql
SomeTable
| top 10 by TimeGenerated desc
```

## Second query

```kql
SomeTable
| top 10 by TimeGenerated desc
```

## Third query

```kql
SomeTable
| top 10 by TimeGenerated desc
```

Result in VSCode

Seems it alternates too. So all text under an odd number of kql / kusto code blocks does not get proper regular markdown highlighting.

If you change codeblock to something else like sql instead, highlighted markdown outside a codeblock is not affected:

The following is syntactically correct code, but it breaks syntax highlighting.

let myVar = "a\\";
let myOtherVar = "whatever";

i always have trouble authenticating with data explorer (web ui works, but kusto explorer does not), so it's def not specific to kuskus but is there any other way to authenticate? or maybe to choose a specific tenant id?

also i know nothing about vscode extensions or typescript but just wanted to say thanks for this! was disappointed there's no kusto extension in VS so this is nice. i'd like to learn enough to make an extension for kusto similar to mssql in VSCode or npgsql in VS, but who know...

https://learn.microsoft.com/en-us/azure/data-explorer/kusto/query/take-any-aggfunction

It replaces the deprecated any() function.

gh-action-bump-version was missing "skip-push" capability, so I added it downstream here to use. I then contributed it back upstream in phips28/gh-action-bump-version#143.

This issue tracks removing the downstream use in .github\actions\gh-action-bump-version-master in favor of upstream phips28/gh-action-bump-version, which can only be done once a new version is released.

Right now, for some reason, to get functions to show up in the completion list, the user must first type database('DatabaseName').. Most functions are not called this way, and it's not intuitive that this is required. It would be great if the completion list could include functions in the default database without requiring the prefix.

That matches all the colors in the KE dark theme

We directly include some versions of these dependencies in this repo. This is kinda janky but got us off the ground.

The packages are

• @kusto/language-service
• @kusto/language-service-next

We should probably just use @kusto/language-service, once all the changes that we depend on are incorporated. The files we'll be able to drop (and instead reference the versions in node_modules) are:

• Kusto.Language.Bridge.min.js
• bridge.min.js
• typings/MissingFromBridge.d.ts
• typings/refs.d.ts

[Feature Request] Markdown Syntax Highlighting Support

Reproduction

For those that don't know, when you create a codeblock in a VSCode markdown document, you can put many well-known languages on the same line, and it will provide syntax highlighting. Copy/paste the following in a VSCode markdown documen to see what I mean.

```Python
# Python comment
print("Hellow World")
```

"Python" and "py" provide syntax.

"Golang" and "Go" uses different comment blocks, just to illustrate that it is language specific

```Golang
package main
import ("fmt")

func main() {
  // This is a comment
  fmt.Println("Hello World!")
}
```

However, with KQL/Kusto, it has no syntax highlighting, and defaults to the standard codeblock.

```Kusto
// This is a kusto comment 
someTableName
| search "HelloWorld"
```

Request

I'm not sure if it's possible to add this feature via kuskus, or if it would have to be added to the default Markdown package (or somewhere else).

If it can't be added, but you have any other information about where or how a user might manually wedge in their own markdown language support, I would appreciate anything you have to offer.