DEV Community: Will Kennedy

Borsh to JSON in Rust using only schemas

Will Kennedy — Sun, 03 Sep 2023 14:45:18 +0000

tl;dr

Use this utility to generate a binary schema file from a Rust struct that implements the BorshSchema trait. Then using the schema file, easily convert to and from JSON and Borsh. No code generation needed.

Source

https://github.com/wkennedy/borsh-schema-utils

[dependencies]
borsh-schema-writer = "0.1.0"
borsh-serde-adapter = "0.1.0"

Overview

Serialization is an essential process for transmitting and storing data, offering various approaches and technologies to suit different use cases. In many instances, the data that needs to be serialized is predetermined, allowing for the use of libraries that generate code for serialization and deserialization (known as non-descriptive). This approach aligns with Borsh's methodology. However, there are situations where the data to be serialized is not known in advance or when the recipient of the serialized data cannot utilize generated code effectively. This is where borsh-schema-utils libraries come into play.

Data often traverses freely and finds its way to unknown consumers. Depending on the circumstances, maintaining generated code from a schema can prove challenging - this might occur when working with a language lacking a readily available library for simple serialization/deserialization or when dynamic implementation becomes necessary. Nevertheless, almost every programming language possesses JSON parsing capabilities; if not already integrated within it, implementing such functionality tends to be relatively straightforward. The borsh-schema-utils offers utilities that facilitate schema generation from Rust structs through its BorshSchema trait while concurrently enabling seamless transformation between JSON format and Rust struct representation.

borsh-schema-writer

The library includes a feature that allows for the extraction of a Struct with the BorshSchema trait and saving its schema to a designated file. This file can then be stored in various locations such as registries, file systems, databases, web storage, and more. This enables consumers to access and utilize the schema as needed. Here's an example of how it works:

use std::fs::File;
use std::io::BufReader;
use borsh::{BorshDeserialize, BorshSerialize, BorshSchema};
use borsh::schema::{BorshSchemaContainer, Definition, Fields};
use borsh_schema_writer::schema_writer::write_schema;

#[derive(Debug, Default, BorshSerialize, BorshDeserialize, BorshSchema)]
pub struct Person {
    first_name: String,
    last_name: String
}

fn write_schema_example() {
    write_schema(Person::default(), "./tests/schema/person_schema.dat".to_string());
    let file = File::open("./tests/schema/person_schema.dat").unwrap();
    let mut reader = BufReader::new(file);
    let container_from_file = BorshSchemaContainer::deserialize_reader(&mut reader).expect("Deserialization for BorshSchemaContainer failed");
}

Neat. Now you have a schema file that can be used by consumers to deserialize data. Let's see how that can be done.

borsh-serde-adapter

The library offers functions for converting serialized data from Borsh into a serde_json value using the binary file produced by the borsh-schema-writer library. By utilizing this library, you can convert a serde_json value into its corresponding borsh serialization. To illustrate, here is an instance of deserialization in action:

fn deserialize_from_borsh_schema_from_file() {
    let person = Person {
        first_name: "John".to_string(),
        last_name: "Doe".to_string(),
    };

    let person_ser = person.try_to_vec().expect("Error trying to seralize Person");

    let file = File::open("./tests/schema/person_schema.dat").unwrap();
    let mut reader = BufReader::new(file);
    let container_from_file = BorshSchemaContainer::deserialize_reader(&mut reader).expect("Deserializing BorshSchemaContainer failed.");

    let result = deserialize_from_schema(&mut person_ser.as_slice(), &container_from_file).expect("Deserializing from schema failed.");
    println!("{}", result.to_string());
}

Here is the result:

{"first_name": "John", "last_name": "Doe"}

In this example you can see that we aren't deserializing a struct with the BorshDeserialize trait. Typically, you would do something like this:

let person_serialized = person.try_to_vec().expect("Error trying to serialize Person");
let person_deserialized = Person::deserialize(&mut person_serialized.as_slice());

But with the schema, we can go from borsh serialized, directly to serde_json and then we can easily get JSON as a string. This makes it much easier for other consumers to handle.

We can do something similar with serializing from serde_json to borsh.

fn serialize_from_borsh_schema_with_string() {
    let file = File::open("./tests/schema/person_schema.dat").unwrap();
    let mut reader = BufReader::new(file);
    let person_schema = BorshSchemaContainer::deserialize_reader(&mut reader).expect("Deserializing BorshSchemaContainer failed.");

    let person_value = json!({"first_name": "John", "last_name": "Doe"});
    let mut person_writer = Vec::new();

    let _ = serialize_serde_json_to_borsh(&mut person_writer, &person_value, &person_schema).expect("Serialization failed");

    let result = deserialize_from_schema(&mut person_writer.as_slice(), &person_schema).expect("Deserialization failed");
}

Here you can see instead of serializing from the Person struct with the BorshSerialize trait, we were able to go from serde_json directly to borsh serialization, with person_writer containing the serialized struct as a vec of bytes.

Borsh Schema to JSON

It's possible to get the schema as JSON. This is useful for consumers that utilize the binary file. This can be done using the write_schema_as_json function. Here is an example:

fn schema_to_json_test() {
    write_schema_as_json(Person::default(), "./tests/schema/person_schema.json".to_string());
    let file = File::open("./tests/schema/person_schema.json").unwrap();
    let reader = BufReader::new(file);
    let result: Value = serde_json::from_reader(reader).expect("Deserialization failed");
    println!("{}", result.to_string());
}

This will result in the following JSON:

{
  "declaration": "Person",
  "definitions": [
    [
      "Person",
      {
        "Struct": {
          "fields": {
            "NamedFields": [
              [
                [
                  "first_name",
                  "string"
                ],
                [
                  "last_name",
                  "string"
                ]
              ]
            ]
          }
        }
      }
    ]
  ]
}

Conclusion

I hope you've enjoyed having fun with serialization! If you have any questions, please feel free to reach out to me.

Creating Solana webhooks with Helius, TypeScript and Rust

Will Kennedy — Mon, 28 Aug 2023 16:21:47 +0000

This tutorial will show you how easy it is to create your own webhook to tap into Solana events and send them to your applications, either parsed or in raw formats. Using webhooks is a great alternative to synchronous requests or websockets, especially if you aren't looking for two way communication.

All code for this tutorial can be found here:

https://github.com/wkennedy/helius-webhooks-tutorial

Overview of what you'll do in this tutorial

Create an ngrok account (https://ngrok.com/)
Create an account on Helius (https://www.helius.dev) in order to push data to the webhook you'll create
Create a simple application using TypeScript with an HTTP endpoint as the webhook.
(Optional) Create a simple application using Rust with an HTTP endpoint as the webhook.

Assumptions

You already have npm installed
You have cURL installed
(optional) You already have Rust installed.

Step 1 - Setup an ngrok account

Because we'll be running our webhook locally (localhost:3000/webhook), we need a way to tell Helius how to send a request to our localhost. There are several ways to do this, but the easiest is to use ngrok (https://ngrok.com/). Sign up is free and straightforward. Once you do that, you can download ngrok to your machine (Windows, MacOS, Linux). Once that is installed you can check to see if it's working:

 ngrok -v

If that successfully prints the version you installed then you can run:

ngrok http 3000

After executing that command you should see something like this:

Forwarding https://3214-199-223-251-92.ngrok-free.app -> http://localhost:3000

This means, you can now use "https://3214-199-223-251-92.ngrok-free.app" and a public facing URL that will forward to your localhost. This URL is what we'll use to configure Helius.

Step 2 - Setup

This step will go over creating a webhook using the Helius UI, but an alternative is to do it programmatically using there SDK (https://github.com/helius-labs/helius-sdk#webhooks).

If you don't already have a Helius (https://www.helius.dev) account, you can create one for free. It will generate a project name for you and ask you to generate a new API key.

Click the button and it will generate a new key and forward you to your new dashboard.

You'll see two a devnet and mainnet URL that you can use for Solana RPC endpoints, but what we are interested in is the webhook functionality. Let's click on the webhook link in the navigation menu.

Click the "New Webhook" button. Now we'll configure the webhook using the URL that ngrok provided, but with the addition of "/webhook": https://3214-199-223-251-92.ngrok-free.app/webhook

The applications we'll make in next section will use "webhook" as the path for the HTTP endpoint.

Step 3 - Webhook (Node)

For this application, we'll create a simple web application using Express. The webapp will have a single POST endpoint, "/webhook", that will be called by Helius. Let's start by taking a look at the ts-app/package.json file. The application will need the following dependencies:

"dependencies": {  
  "@types/express": "^4.17.17",  
  "@types/node": "^20.4.8",  
  "body-parser": "^1.20.2",  
  "express": "^4.18.2",  
  "ts-node": "^10.9.1",  
  "typescript": "^5.1.6"  
}

These dependencies will provide us with TypeScript support, the ability to deploy a web application using Express, and parse the request body as JSON.

If you haven't already, go ahead and do an npm install in the ts-app root to grab the node modules for the project.

cd /helius-webhooks-tutorial/ts-app
npm install

Now let's take a look at the application itself:

import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
const port = 3000;

//We are expecting the body to contain valid JSON from the Helius request
app.use(bodyParser.json());

//This is our actual webhook that is served locally at http://localhost:3000/webhook.
//By using ngrok, the ngrok provided public url will map to our local webhook
//https://3214-199-223-251-92.ngrok-free.app/webhook -> http://localhost:3000/webhook
app.post('/webhook', (request: Request, response: Response) => {

    const requestBody = request.body;
    //Print the JSON to the console
    console.log('Data received by webook: ', requestBody);

    //Send a response that we received and processed the request.
    response.status(200).send('Webhook Request Received!');

});

app.listen(port, () => {
    console.log(`Server is running on port ${port}`);
});

This is a simple application that listens for requests at http://localhost:3000/webhook and simply prints the JSON from the request body to the console. It's up to you what data you want from Helius and how to process it. For this example we are just going to use the test functionality from Helius.

Let's go ahead and start the web application:

npm run start-server

You should see the following output:

> ts-app@1.0.0 start-server
> npx ts-node src/app.ts

Server is running on port 3000

Before we test with Helius, we can check that everything is running okay locally. Issue the following cURL command:

curl --header "Content-Type: application/json" --request POST --data '{"key":"value"}' http://localhost:3000/webhook

You should see the following output in the console:

Data received by webook: { key: 'value' }

So far so good! The JSON we sent via cURL was successfully printed to the console like we expected. Now let's try it from Helius. On the webhook page, there is a button on the the far right where you see the webhook you created earlier. You can see it circled in yellow below. Click that link and approve the confirmation modal that pops up. You should see the following output in the console:

Data received by webook: [
  {
    blockTime: 1673445241,
    indexWithinBlock: 2557,
    meta: {
      err: null,
      fee: 10000,
      innerInstructions: [Array],
      loadedAddresses: [Array],
      logMessages: [Array],
      postBalances: [Array],
      postTokenBalances: [Array],
      preBalances: [Array],
      preTokenBalances: [Array],
      rewards: []
    },
    slot: 171942732,
    transaction: { message: [Array], signatures: [Array] }
  }
]

You can now start requesting data from Helius for your use cases.

Step 4 - Webhook (Rust)

This is similar to Step 3, meaning all we're doing is creating a single POST endpoint to receive the Helius data. Let's start by taking a look at the dependencies in /rust-app/Cargo.toml.

warp = "0.3.5"  
serde = { version = "1.0.183", features = ["derive"] }  
serde_json = "1.0.104"  
tokio = { version = "1.30.0", features = ["rt-multi-thread", "macros"] }  
bytes = "1.4.0"

The "warp" dependency is the web server to serve our webhook. Since warp handles requests asynchronously, tokio is needed to create an asynchronous runtime for warp to operate in. Lastly, serde is used to parse the request body into a JSON struct value.

In the /rust-app directory run:

cargo build

This will download and build all the dependencies needed for this project.

Open the main.rs file in /rust-app/src:

use serde_json::Value;  
use warp::Filter;  
use warp::http::StatusCode;  

#[tokio::main]  
async fn main() {  
    //Create an HTTP POST endpoint "webhook" that takes the request body as bytes  
    //The bytes are then transformed into serde_json Value and printed to the console.  
    //If the JSON is valid, then a 200 code is returned   
    let webhook = warp::post()  
        .and(warp::path!("webhook"))  
        .and(warp::body::bytes())  
        .map(|bytes: bytes::Bytes| {  
            let v: Value = serde_json::from_slice(bytes.iter().as_slice()).expect("Error deserializing from slice");  
            println!("{}", v.to_string());  
            StatusCode::OK  
        });  

    //Create a simple healthcheck endpoint  
    let health_route = warp::path!("health")  
        .map(|| StatusCode::OK);  

    //Create the routes to pass to the server  
    let routes = health_route.or(webhook)  
        .with(warp::cors().allow_any_origin());  

    println!("Webhook Started!");  

    //Start the server on port 3000  
    warp::serve(routes).run(([127, 0, 0, 1], 3000)).await;  
}

When this program is run, it creates a web application server running on port 3000, with two endpoints "/webhook" and "/health". To run the program type:

cargo run

The console output will read:

Finished dev [unoptimized + debuginfo] target(s) in 0.03s
Running `target/debug/rust-app`
Webhook Started!

We can test that our server is running correctly using the same cURL command as in step 3.

curl --header "Content-Type: application/json" --request POST --data '{"key":"value"}' http://localhost:3000/webhook

In the console you'll see the following output:

{"key":"value"}

Now let's try the Helius test button like we did in Step 3. The test output will be displayed in the console, in my case it looked like:

[
   {
      "accountData":[
         {
            "account":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "nativeBalanceChange":-72938049280,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"NTYeYJ1wr4bpM5xo6zx5En44SvJFAd35zTxxNoERYqd",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"AAaTGaA3uVqikfVEwoSG7EwkCb4bBDsMEyueiVUS5CaU",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"autMW8SgBkVYeBgqYiTuJZnkvDZMVU2MHJh9Jh7CSQ2",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"D8TxfGwdu9MiNMoJmUoC9wQfNfNT7Lnm6DzifQHRTy6B",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"5DxD5ViWjvRZEkxQEaJHZw2sBsso6xoXx3wGFNKgXUzE",
            "nativeBalanceChange":71860273440,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"25DTUAd1roBFoUQaxJQByL6Qy2cKQCBp4bK9sgfy9UiM",
            "nativeBalanceChange":-2039280,
            "tokenBalanceChanges":[
               {
                  "mint":"FdsNQE5EeCe57tbEYCRV1JwW5dzNCof7MUTaGWhmzYqu",
                  "rawTokenAmount":{
                     "decimals":0,
                     "tokenAmount":"-1"
                  },
                  "tokenAccount":"25DTUAd1roBFoUQaxJQByL6Qy2cKQCBp4bK9sgfy9UiM",
                  "userAccount":"1BWutmTvYPwDtmw9abTkS4Ssr8no61spGAvW1X6NDix"
               }
            ]
         },
         {
            "account":"DTYuh7gAGGZg2okM7hdFfU1yMY9LUemCiPyD5Z5GCs6Z",
            "nativeBalanceChange":2039280,
            "tokenBalanceChanges":[
               {
                  "mint":"FdsNQE5EeCe57tbEYCRV1JwW5dzNCof7MUTaGWhmzYqu",
                  "rawTokenAmount":{
                     "decimals":0,
                     "tokenAmount":"1"
                  },
                  "tokenAccount":"DTYuh7gAGGZg2okM7hdFfU1yMY9LUemCiPyD5Z5GCs6Z",
                  "userAccount":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX"
               }
            ]
         },
         {
            "account":"rFqFJ9g7TGBD8Ed7TPDnvGKZ5pWLPDyxLcvcH2eRCtt",
            "nativeBalanceChange":1080000000,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"CgXS5xC3qAGSg9txD9bS7BUgugZwshivGXpCJcGmdwrd",
            "nativeBalanceChange":-2234160,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"E8cU1WiRWjanGxmn96ewBgk9vPTcL6AEZ1t6F6fkgUWe",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"11111111111111111111111111111111",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"FdsNQE5EeCe57tbEYCRV1JwW5dzNCof7MUTaGWhmzYqu",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"AYZsWahcrSnkwqbA1ji7wEzgAnGjLNJhVUMDPfACECZf",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"SysvarRent111111111111111111111111111111111",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         },
         {
            "account":"1BWutmTvYPwDtmw9abTkS4Ssr8no61spGAvW1X6NDix",
            "nativeBalanceChange":0,
            "tokenBalanceChanges":[

            ]
         }
      ],
      "description":"5DxD5ViWjvRZEkxQEaJHZw2sBsso6xoXx3wGFNKgXUzE sold Fox #7637 to CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX for 72 SOL on MAGIC_EDEN.",
      "events":{
         "nft":{
            "amount":72000000000,
            "buyer":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "description":"5DxD5ViWjvRZEkxQEaJHZw2sBsso6xoXx3wGFNKgXUzE sold Fox #7637 to CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX for 72 SOL on MAGIC_EDEN.",
            "fee":10000,
            "feePayer":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "nfts":[
               {
                  "mint":"FdsNQE5EeCe57tbEYCRV1JwW5dzNCof7MUTaGWhmzYqu",
                  "tokenStandard":"NonFungible"
               }
            ],
            "saleType":"INSTANT_SALE",
            "seller":"5DxD5ViWjvRZEkxQEaJHZw2sBsso6xoXx3wGFNKgXUzE",
            "signature":"5nNtjezQMYBHvgSQmoRmJPiXGsPAWmJPoGSa64xanqrauogiVzFyGQhKeFataHGXq51jR2hjbzNTkPUpP787HAmL",
            "slot":171942732,
            "source":"MAGIC_EDEN",
            "staker":"",
            "timestamp":1673445241,
            "type":"NFT_SALE"
         }
      },
      "fee":10000,
      "feePayer":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
      "nativeTransfers":[
         {
            "amount":72936000000,
            "fromUserAccount":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "toUserAccount":"AAaTGaA3uVqikfVEwoSG7EwkCb4bBDsMEyueiVUS5CaU"
         },
         {
            "amount":2011440,
            "fromUserAccount":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "toUserAccount":"D8TxfGwdu9MiNMoJmUoC9wQfNfNT7Lnm6DzifQHRTy6B"
         },
         {
            "amount":71856000000,
            "fromUserAccount":"AAaTGaA3uVqikfVEwoSG7EwkCb4bBDsMEyueiVUS5CaU",
            "toUserAccount":"5DxD5ViWjvRZEkxQEaJHZw2sBsso6xoXx3wGFNKgXUzE"
         },
         {
            "amount":1080000000,
            "fromUserAccount":"AAaTGaA3uVqikfVEwoSG7EwkCb4bBDsMEyueiVUS5CaU",
            "toUserAccount":"rFqFJ9g7TGBD8Ed7TPDnvGKZ5pWLPDyxLcvcH2eRCtt"
         },
         {
            "amount":2039280,
            "fromUserAccount":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "toUserAccount":"DTYuh7gAGGZg2okM7hdFfU1yMY9LUemCiPyD5Z5GCs6Z"
         }
      ],
      "signature":"5nNtjezQMYBHvgSQmoRmJPiXGsPAWmJPoGSa64xanqrauogiVzFyGQhKeFataHGXq51jR2hjbzNTkPUpP787HAmL",
      "slot":171942732,
      "source":"MAGIC_EDEN",
      "timestamp":1673445241,
      "tokenTransfers":[
         {
            "fromTokenAccount":"25DTUAd1roBFoUQaxJQByL6Qy2cKQCBp4bK9sgfy9UiM",
            "fromUserAccount":"1BWutmTvYPwDtmw9abTkS4Ssr8no61spGAvW1X6NDix",
            "mint":"FdsNQE5EeCe57tbEYCRV1JwW5dzNCof7MUTaGWhmzYqu",
            "toTokenAccount":"DTYuh7gAGGZg2okM7hdFfU1yMY9LUemCiPyD5Z5GCs6Z",
            "toUserAccount":"CKs1E69a2e9TmH4mKKLrXFF8kD3ZnwKjoEuXa6sz9WqX",
            "tokenAmount":1,
            "tokenStandard":"NonFungible"
         }
      ],
      "type":"NFT_SALE"
   }
]

Now that you have the data, you can extract values, for example:

println!("{}", v[0]["type"]);  
println!("{}", v[0]["accountData"][0]);

Alternatively, you can create a struct and use serde to transform the JSON payload into a struct for you to use in your application.

Rust Profiling in WSL2 with CLion

Will Kennedy — Mon, 28 Aug 2023 02:48:00 +0000

Code from this example is here:

https://github.com/wkennedy/wsl2-rust-profiling

Having recently switched some of my coding to remote development in WSL2 with CLion, I noticed that profiling was not readily available. I tried various proposed solutions, but didn't have much success until I came across this gist:
https://gist.github.com/abel0b/b1881e41b9e1c4b16d84e5e083c38a13

At the bottom of that thread is a suggestion to run these commands:

In the Windows shell run:

wsl --update

Then in WSL2 (assuming it's Ubuntu) run:

sudo apt update
sudo apt install flex bison
sudo apt install libdwarf-dev libelf-dev libnuma-dev libunwind-dev \
libnewt-dev libdwarf++0 libelf++0 libdw-dev libbfb0-dev \
systemtap-sdt-dev libssl-dev libperl-dev python-dev-is-python3 \
binutils-dev libiberty-dev libzstd-dev libcap-dev libbabeltrace-dev
git clone https://github.com/microsoft/WSL2-Linux-Kernel --depth 1
cd WSL2-Linux-Kernel/tools/perf
make -j8 # parallel build
sudo cp perf /usr/local/bin

After those updates are done, go to the CLion settings you and search for "profiler" and check that perf is configured correctly:

When you try to run your application with profiling, you may see an error stating the profiler can't start:

If you click on the notifications tab in the upper right corner, you'll see more details on the error along with the ability to configure a fix. When you click "configure" you'll see the following suggestion. Depending on your setup you may see more commands to run and you may have to manually run the suggested commands manually in your WSL2 terminal.

Once the kernel variables are set we can attempt to profile our application again.

If the program run successfully you should see a message in the right lower corner stating that the profiler is attached and finally that the profiling results are ready to view. You can also open the results from the notification tab.

Click "open" and you'll see the results graph.

There is a lot to digest here, and digging through this data is for another post. But for now we can try to identify the hot spots in the code. Looking at this graph we can see our main function, then right above it two of our other functions, "nested_loop_one" and "nested_loop_two". Let's look at the call tree of t he execution just for the wsl2-rust-profiling application. Expand the call tree:

We can clearly see the functions in our code that are taking the longest time to run. Of course, this is a simple example with functions that we new ahead of time were less than ideal. But we now have profiling working with CLion and WSL2 which are powerful tools to better optimize our code.