Were you ever curious about how companies like Uber, Just Eat, and Strava show you the location of your delivery, ride, or run in real-time? Well, in this tutorial we will go over the two main ways that map data can be displayed and interacted with on a web page. 

a discussion of the two main ways to display map data on a web page, and their pros and cons

inserting actual map data into the database

spinning up a geoserver to serve the map data

spinning up a geographical REST API to serve the map data

displaying the map data on a web page using streamlit and folium


In the following video demo our resident Python Developer, James Twose, will show you how it is done!

Displaying map data on a web page: geoserver vs geoapi

We hope you enjoyed this tutorial and now have a better understanding of how to display map data on a web page.

If you have any questions or comments, please feel free to reach out to us on our social media channels or via email.

You can find the code for this tutorial here: https://github.com/jameshtwose/geoserver-vs-pygeoapi

Were you ever curious about how companies like Uber, Just Eat, and Strava show you the location of your ride, delivery, or run in real-time? In this tutorial we will go over the two main ways that map data can be displayed and interacted with on a web page.

Displaying map data on a web page: Geoserver vs geoapi

Geoserver vs geoapi

Heb je altijd al willen spreken op een conferentie maar weet je niet waar je moet beginnen? Of wil je je simpelweg je presentatievaardigheden verbeteren? Meld je dan aan voor de CINQ Sprekersopleiding! 

Na het succes van twee interne edities met onze CINQ collega’s, gaat in oktober 2024 de CINQ Sprekersopleiding open voor het publiek. 

De opleiding bestaat uit vier avonden waarin je wordt klaargestoomd voor je eerste optreden. In oktober, november, januari en februari zijn de opleidingsavonden en in maart vindt de CINQ Conferentie plaats: daar ga jij je presentatie voor publiek geven! 

hoe schrijf je een goed voorstel (paper)?

hoe maximaliseer je je kansen om geselecteerd te worden?

Tijdens de avonden word je voorzien van de benodigde kennis, en ga je vooral ook veel oefenen met presenteren. De deelnemers gaan elkaar beoordelen en van feedback voorzien. Aan het einde van het traject heeft iedereen een goed beeld van wat er nodig is om op een conferentie te kunnen spreken. Niet alleen het spreken zelf, ook alle stappen die voorafgaan aan het spreken op een conferentie heb je dan onder de knie.

We sluiten het traject af met de CINQ conferentie waarbij je je nieuwe vaardigheden in een presentatie voor publiek gaat laten zien. Hierna blijft Bouke beschikbaar als je coach en zal hij je begeleiden naar je eerste “optreden” als spreker op een conferentie.

Deelname aan de CINQ Sprekersopleiding kost €250 exclusief btw. Hiervoor krijg je:

vier avonden opleiding inclusief avondeten

training en begeleiding door een ervaren internationaal spreker: Bouke Nijhuis

begeleiding na het traject naar je eerste conferentie

Klik hier om je aan te melden. Je zit nog nergens aan vast. Na je aanmelding nemen we zo snel mogelijk contact met je op. 

Bekijk een impressie van de vorige CINQ Conferentie:

CINQ CONFERENTIE AFTERMOVIE 2024

Heb je altijd al willen spreken op een IT conferentie maar weet je niet waar je moet beginnen? Of wil je je simpelweg je presentatievaardigheden verbeteren? Meld je dan aan voor de CINQ Sprekersopleiding!

Meld je aan voor de CINQ Sprekersopleiding

CINQ Sprekersopleiding

Kun je al (een beetje) programmeren en ben je benieuwd naar Python? Kom langs en leer van Bart van Dijk waarom Python een fijne taal is om snel mee te kunnen developen.

De workshop
In de workshop leer je over de datatypes binnen Python en een aantal geavanceerdere concepten. Vervolgens laat Bart zien hoe je Clean Code kunt schrijven in Python.

Als afsluiter kan er gekozen worden tussen een set opdrachten voor Object-Georienteerd Programmeren, Functioneel Programmeren, of algoritmische opdrachten a la Advent of Code.

Voor wie is deze workshop?
Developers, DevOps- en Data-engineers met al enige ervaring in programmeren.

Hoe kan ik me voorbereiden?
Zorg dat je je favoriete IDE (bijvoorbeeld VSCode) paraat hebt die Python ondersteunt. (Of Notepad als je van hardcore code schrijven houdt)

Het programma
17.00u - inloop met eten
18.00u - start workshop
20.00u - borrel / netwerken

Het is een workshop, dus neem je laptop mee!

Kom naar de Python workshop op 10 september

Splunk 9.3 has been released and  there are some new features that we would like to share with you. In the release notes you can find all the features added to this release.

Dashboard Studio - Scheduled PDF and PNG export

It is now possible to schedule PDF or PNG exports for Dashboard Studio dashboards.  For users to be able to do this you have to give them the ‘list_settings’ capability. There are a few limitations that you should consider, see the Splunk Documentation for the details.

A nice bonus is the ability to use the API to fetch a PNG, this means that you can use your automation tooling to fetch a PNG of a dashboard and display that on a website. This is much easier than using embedded reports.

Instead of Python 3.7 the new default is now Python 3.9, you could override this in your app settings but we highly recommend testing all your Python scripts in a test environment with Splunk 9.3 before upgrading on production. 

On busy search heads it is now possible to apply a memory reduction measure for the Splunkd process. In the Splunk conf description it does state that you should consult Splunk support before enabling this setting. 

If you used role-based field filters then you should know that after upgrading these filters will no longer work. You might want to check out the new field filter option, but keep in mind that you can no longer use the following commands: mpreview, mstats, tstats, typeahead, and walklex

If you use Splunk Enterprise Security you probably won’t be able to use this since Splunk Enterprise Security relies heavily on tstats. For more information click this link. 

Indexer cluster rolling upgrade automation

If you have not yet automated your Splunk indexer cluster upgrade you might want to check out this app that helps you. Do note that using systemd for Splunk is currently not supported.
https://docs.splunk.com/Documentation/Splunk/9.3.0/Indexer/AutomatedIDXCrollingupgrade

Splunk 9.3 has been released and we highlight some of the new features in this blogpost.

Splunk 9.3 new features explained

Splunk 9.3 - new features explained

Ieder jaar trekken we er met onze collega's op uit voor een actief uitje. Dit keer kwamen we samen op het mooie terrein van de Middengaarde in Nieuwegein. 

Hier werden we getrakteerd op een heerlijke barbecue, leuke activiteiten en als bonus mochten we ook op het terrein blijven overnachten. Na een gezellige avond / nacht bij het kampvuur konden we zo naar onze tent kruipen. De CINQ Camping, voor herhaling vatbaar? 

CINQ EXPERIENCE 2024 - Aftermovie

Wil jij er de volgende keer ook bij zijn? Check dan onze vacatures

Aftermovie CINQ Experience

Ever wondered how your API would perform under heavy load? Load testing is a way to simulate a high number of users accessing your API at the same time. This can help you identify bottlenecks in your system and help you optimize your API for better performance.

Well luckily enough one of our data engineers, James Twose, will give a video demo on how to use the open source Python framework Locust to load test your API.

Locally run a postgres database and a fastapi-sqlalchemy API using docker-compose

Loadtesting your API with Locust

We hope you enjoyed the demo and learned something new about load testing. If you have any questions or feedback, feel free to reach out to us on our social media channels. You can find the code for this demo here: https://github.com/jameshtwose/api-framework-comparison

In this video data engineer James Twose shows you how to loadtest your API using Locust.

Wat ooit is begonnen als een hackathon bij DHL, één van onze klanten bij CINQ ICT, is nu een framework aan het worden om Azure resources aan te maken en te beheren. Het idee was om de Infrastructure as Code weg te abstraheren bij de ontwikkel teams, maar om de resources via configuratie files (bijv. YAML) aan te kunnen maken. Deze manier van werken zou ook een eerste stap kunnen zijn naar een vorm van self-service.

Terraform is een van de meest gebruikte tools om infrastructuur in te richten vanuit code (IaC). Het gebruikt hiervoor een taal genaamd HCL (Hashicorp Configuration Language). In deze blogpost onderzoeken we hoe we het aanmaken van resources kunnen configureren in YAML files en wat de voordelen hiervan zijn.

Een van de beste eigenschappen van YAML is de afwezigheid van “syntax overhead”. Hiermee kunt je key value pairs overzichtelijk opschrijven. Laten we eens kijken naar een vergelijking van bepaalde HCL-code en YAML.

locals {
  storage_accounts = [
    {
      name                     = "storageaccountname"
      account_tier             = "Standard"
      account_replication_type = "ZRS"
      access_tier              = "Hot"
      containers               = [
        {
          name                  = "vhds"
          container_access_type = "auto"
        }
      ]
    }
  ]
}

storage_accounts:  - name: storageaccountname
    account_tier: Standard
    account_replication_type: ZRS
    access_tier: Hot
    containers:
      - name: vhds
        container_access_type: auto

Zoals je kunt zien, is het verschil in aantal regels behoorlijk groot. Natuurlijk zal dit veranderen zodra we wat HCL-code toevoegen om de YAML-configuratie te importeren, maar dit wordt snel groter als de infrastructuur groeit.

Het laden en converteren van een YAML-bestand naar HCL is heel eenvoudig. Je kunt het op één regel doen met behulp van de yamldecode en file functies:

locals {
  config = yamldecode(file("config.yaml"))
}

Na het inlezen van alle yaml files is er een Terraform map beschikbaar met alle resource-types en de in de yaml geconfigureerde properties.

config = {
  "keyvaults" = [
    {...},
    {...}
  ]
  "storage_accounts" = [
    {...},
    {...}
  ]
}

De "router" module is de orchestratie module en de spin in het web die meerdere resources en/of resources-typen aan kan maken. De router module leest alle yaml files in en roept voor iedere resource-type de betreffende resource module aan. Als er in de yaml file meerdere resources van hetzelfde type worden aangemaakt dan zal middels een for_each loop de resource module meerdere malen worden aangeroepen.

module "keyvaults" {
  for_each = {
    for resource in lookup(config, "keyvaults", []) :
    resource.name => resource
  }
  source = "../../microsoft.keyvault/vaults"
  keyvault_info = each.value
}

Om de resource module folder structuur te geven, gebruiken we het resource-type als folder naam.

modules/
├── internal
│   ├── global
│   ├── router
├── datastax
│   └── astradb
├── microsoft.cache
│   └── redis
├── microsoft.datafactory
│   └── factories
├── microsoft.dbforpostgresql
│   └── flexibleservers
│       ├── databases
├── microsoft.eventhub
│   └── namespaces
│       └── eventhub
├── microsoft.keyvault
│   └── vaults
├── microsoft.sql
│   └── servers
│       └── databases
├── microsoft.storage
│   └── storageaccounts
├── microsoft.synapse
│   ├── spark_pool
│   └── workspaces
└── microsoft.virtualmachine

De resource module zal de daadwerkelijk resource aanmaken en bevat alle validatie regels op de input parameters die noodzakelijk zijn. Verder zal de module verplichte parameters afdwingen en "waarden van gezond verstand" gebruiken voor niet verplichte niet opgegeven properties.

variable "storageaccount_info" {
  type = object({
    name                          = string
    account_tier                  = string
    account_replication_type      = string
    access_tier                   = string
    is_hns_enabled                = optional(bool, false)

    containers = optional(list(object({
      name                  = string
      container_access_type = optional(string, "private")
    })), [])

    tags        = optional(map(any), {})

    validation {
      condition     = contains(["Standard", "Premium"], var.sa_info.account_tier)
      error_message = "Invalid account tier. Valid options are 'Standard' and 'Premium'."
    }

    validation {
      condition     = contains(["LRS", "GRS", "RAGRS", "ZRS", "GZRS", "RAGZRS"], var.sa_info.account_replication_type)
      error_message = "Invalid account replication type. Valid options are 'LRS', 'GRS', 'RAGRS', 'ZRS', 'GZRS' and 'RAGZRS'."
    }

    validation {
      condition     = contains(["Hot", "Cool"], var.sa_info.access_tier)
      error_message = "Invalid access tier. Valid options are 'Hot' and 'Cool'."
    }
}

Ook zal de resource module best practices implementeren (denk bijv. aan privacy-by-design principes zoals private endpoints, encryptie, logging) zonder dat dat in de yaml files is aangegeven. De maker van de yaml file hoeft alleen maar de meest voor de hand liggende properties in te vullen zoals bijv. de naam van de resource en de uitvoering (SKU, pricing tier).

YAML-bestanden zijn eenvoudiger dan Terraform locals en/of tfvars-bestanden voor het beheren van niet-triviale Terraform-configuraties. Omdat development teams nu zelf YAML files kunnen aanmaken is dit een eerste voorzichtige stap naar een vorm van self-service.

Binnen de DevOps-unit van CINQ ICT gaan we dit jaar een Terraform hackathon organiseren om te kijken of we dit concept nog verder kunnen uitwerken. Zo heeft iedere resource module een scope van alleen zichzelf en heeft dus geen weet van het bestaan van meerdere en/of andere resource-typen.

Een belangrijk onderwerp van de hackathon zal dan ook zijn hoe we een integratie laag tussen de verschillende modulen kunnen realiseren. Denk daarbij bijv. aan hoe koppelen we een keyvault aan een Kubernetes namespace, of een storage account aan een Synapse Workspace, hoe gaan we om met firewall rules? Zonder daarbij de code in de modules heel complex te maken.

In dit blog lees je hoe we met behulp van yaml files Terraform resources kunnen configureren.

Metadata driven Terraform deployments

In this blog I’ll demonstrate how to build a Splunk XML Dashboard by using AI only. Following a case study, I will guide you step-by-step from the initial concept to a fully developed dashboard. 

For this exercise, I used the Cinq ICT website as a base and reference for the layout and aim to create a dashboard that can serve as the homepage for a Cinq ICT Splunk app. For the dashboard code generation, I’m making use of so-called Large Language Model (LLM) bots. In this case chat GPT, the 3.5 free version. I’ll also use the Dall-E 3 image generation via Microsoft CoPilot to generate some logo images for our Data, DevOps, and Development Unit. Feel free to use the prompts in this case study in combination with other LLM bots to see the differences in the image or code generation.

Below I visualized the concept for the Splunk dashboard. The goal is that AI creates the code for each dashboard component, based on 4 prompts.  

1. At the top, we have a header that includes an image with accompanying text below and on the right. 
2. Below that, there will be a headline row “App Dashboards”, a copy of this code will be used to create the “Links/Help” headline.
3. Between these 2 headlines we have 4 tiles with the dashboard 1/2/3/4 links
4. At the bottom, a list of URLs. 

The colors indicated in the color schema are picked from the cinq website and will consistently be used in the AI prompts. The blue circles in the header will be replaced with the generated images.

When asking things to a LLM bot like ChatGPT it’s important to take the following tips/tricks into account for better responses.

1. Be Precise: Clear, detailed inputs yield better responses.
2. Simplify: Break complex questions into shorter ones.
3. Follow-Up: Ask clarifying questions if needed.
4. Provide Context: Background information enhances relevance.
5. Highlight Keywords: Emphasize important terms to focus the response.
6. Avoid Ambiguity: Frame questions clearly to reduce misunderstandings.
7. Confirm Understanding: Summarize responses to check accuracy.

The general idea is to leave few to no room for interpretation, as that will cause inaccurate responses. 

As shown in the concept above we need 4 prompts to generate the dashboard. We’ll take it top-down and begin with the header, applying the tips outlined above. I’ll write the below query in chatGPT. Based on my experience with AI and Splunk code dashboard generation, I know that I need to explain a few more details to get the right response. I already instructed chatGPT to change the <dashboard> tag by including version 1.1, a light theme, and a hidden title. I also ensure to use self-closing <br> and <img> tags. Finally, I eliminated the grey spaces between rows using CSS. If you don’t know – and therefore may not apply - these instructions you will get code that does not work properly in Splunk and then you need to manually apply these fixes in Splunk, also a good exercise. 

Prompt 1 - Header
Please create a header for a Splunk XML dashboard using HTML/CSS. I need a white background with rounded corners with 3 mid-left-aligned image placeholders from left to right (logo_1.png, logo_2.png, logo_3.png) in the Splunk Search app directory, 350px wide and 100px tall). 8px padding-bottom, Below the image, include the text "Data | DevOps | Development" in #575756, with the '|' in orange (#F39201), all bold and 24px. On the right, place the text "CINQ ICT" in bold, 48px, #575756, padding-right 80px padding-botton 12px, with a smaller subtitle "Net iets meer | net iets anders" in #ABABAB, 26px, no padding. Use <dashboard version="1.1" theme="light" hideTitle="true"> to start, and ensure all image and br tags are self-closing. With CSS set the .dashboard-header class min-height to 0px; and the .panel-body.splunk-html padding to 0px;

Optional Prompt: Images
Generate a logo, a circle shape that symbolizes Data Analytics using only colors #58ADDF , #575756, #F39201.

For the 3 images I have used the above prompt, changing the text “Data Analytics” to “DevOps” and “IT Coding/Development”. Using Microsoft Designer, I Downloaded the images and placed them locally in Splunk search app folder src="/static/app/search/data.png".

The first prompt with the images gives the following result, note that it will slightly differ each time based on what chatGPT generates. It looks as follows:

Prompt 2 - Headlines
For an existing Splunk XML dashboard I need a new row that creates a small headline with rounded corners. A white background and a text “App Dashboards” in blue #58ADDF, bold and 16px, aligned left. So start and end with the row tag, omit the dashboard tag.

Note that I instructed chatGPT to clearly only add the row tag here, so we append to our previous code. I copy the rows 2 times in Splunk, so I have both headline rows. The code is now as follows and the dashboard looks like this:

Prompt 3 – Tiles
For an existing Splunk XML dashboard I need a new row with 4 clickable tiles from left to right with height 75. Each tile must have rounded corners, a white background and the text “Dashboard” with a number 1,2,3,4, text in blue #58ADDF , bold and 20px, aligned centre. The tiles need a hover and onclick to another Splunk dashboard.  The first tile needs no margin on the left side, and the last one needs no margin on the right side. All style attributes are in separate style tags. Start with the row tag and omit the dashboard tag.

I add the row prompt result from chatGPT between the 2 headline rows, to add the 4 dashboard link tiles. The result looks as below. Note that the hover function is also added and even came with some advanced CSS transitioning for a smooth background change. 

Prompt 4 – Links/Help
For an existing Splunk XML dashboard I need a row with a with background and rounded corners. In this row I need a list of URLs underneath each other with mouse hover functionality. The link URLs are: “Home”, “What we do – Data”, “About CINQ”, “Events”, “Podcast”, “Blog”, “Vacancies”, “LinkedIn - Tom de Bruijn”. The URL text in blue #58ADDF , bold and 16px, aligned left. Start with the row tag omit dashboard tag.

After Prompt 4 The final code results in this and looks like below. 

I hope you found this case study informative and enjoyed reading the blog! If you'd like to connect, feel free to add me on LinkedIn at https://www.linkedin.com/in/tcdebruijn/. I'm always more than happy to chat or help out if needed. 

In this blog Tom de Bruijn demonstrates how to build a Splunk XML Dashboard by using AI only. Following a case study, he will guide you step-by-step from the initial concept to a fully developed dashboard.

Build a Splunk Dashboard with ChatGPT or AI only

Build a Splunk Dashboard with ChatGPT

It’s not a secret: we at CINQ love to use Cribl products. We’re particularly fond of using Cribl Stream, and we like it so much, we’re even doing workshops on the matter to show people what you can do with Cribl Stream. Cribl itself says Cribl Stream is an Observabilty Pipeline, but before we get lost into what an Observability Pipeline exactly means, what Cribl Stream can do is collect data from any data source, filter out any parts of the data that you don’t need, transform the data in a format of your choosing, and send the data to a data destination. You can get started with Cribl for free in their sandbox environment here.

One of the assignments in our recent Cribl workshop is based on a real life use case from one of our customers, and the few times we’ve given this workshop, participants were struggling a bit with this assignment.

Since there’s not much time available during our workshop to fully get into detail about why you have to do some steps, here’s a little blog post to cover that need.

The National Data Portal for Road Traffic (Nationaal Data Portaal Wegverkeer, or NDW for short) is a Dutch national portal for road traffic data in the Netherlands, both from national roads, provincial roads and from municipal main roads.

In NDW, Dutch governments work together to collect, combine, store and distribute mobility data. This data is used for traffic management.

First, the NDW has a platform available where the traffic data is posted: the Open Data Portal (​​https://opendata.ndw.nu/) 

For the workshop assignment we’re interested in Ongevalideerde_snelheden_en_Intensiteiten.xml.gz, a file which consists of the average speed and intensity of all measure points of all national roads of the country. That’s over 24000 measure points. In a single XML file. Compressed as a gzip file. Updated every single minute.

Let that sink in for a moment and let’s take a closer look at the structure of the XML file itself.

<?xml version="1.0" encoding="UTF-8"?>
<SOAP:Envelope xmlns:SOAP="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP:Body>
    <ndw:NdwMrm xmlns:ndw="http://schemas.ndw.nu/wsdl/NdwTmisMrm10/">
      <ndw:exchange>
        <subscription>
          <subscriptionState>active</subscriptionState>
          <updateMethod>snapshot</updateMethod>
        </subscription>
      </ndw:exchange>
      <minute_speed_and_flow_events xmlns="http://speed_and_flow.trafficmanagementinfo.publicatie.hwn.rws.nl/1.1">
        <meta>
          <msg_id>
            <uuid>97b3eddf-cf1c-43cc-ae0f-e2e55ab0d22b</uuid>
          </msg_id>
          <selection />
        </meta>
        <event>
          <ts_event>2019-09-19T12:21:27.741Z</ts_event>
          <ts_state>2019-09-19T11:40:53.853Z</ts_state>
          <measuring_point_id>
            <uuid>e9af9383-2d7f-4963-88c9-38aa1d9c33cc</uuid>
          </measuring_point_id>
          <lanelocation>
            <road>A2</road>
            <carriageway>g</carriageway>
            <lane>3</lane>
            <km>64.242</km>
          </lanelocation>
        </event>
        <event>
          <ts_event>2023-08-20T19:05:06.285Z</ts_event>
          <ts_state>2023-08-20T19:05:00Z</ts_state>
          <measuring_point_id>
            <uuid>e9af9383-2d7f-4963-88c9-38aa1d9c33cc</uuid>
          </measuring_point_id>
          <avgspeed>
            <kmph>92</kmph>
          </avgspeed>
        </event>
        <event>
          <ts_event>2023-08-20T19:05:06.286Z</ts_event>
          <ts_state>2023-08-20T19:05:00Z</ts_state>
          <measuring_point_id>
            <uuid>e9af9383-2d7f-4963-88c9-38aa1d9c33cc</uuid>
          </measuring_point_id>
          <flow>
            <count>6</count>
          </flow>
        </event>
        …
        …
        …
      </minute_speed_and_flow_events>
    </ndw:NdwMrm>
  </SOAP:Body>
</SOAP:Envelope>


We can see that the interesting parts are under element event and that the same  measuring_point_id is mentioned 3 times under 3 different event elements.

Event 1: you can identify the measuring_point_id to the physical location of the measuring point on the specified national road. 

Event 2: you can see the average speed for a specific measuring_point_id

Event 3: you can see the number of vehicles for a specific measuring_point_id

So, everything we need is located on a website in a compressed XML file of around 1.6 MB. Decompressed the file is around 18 MB.

What we need in Cribl, is to get to the gzip file, decompress it to get the XML file, and create separate events for every, well, event .

This is the easiest part. Setup a REST API source pointing to the URL of the file. As if it’s nothing, Cribl will get the file and automatically decompress it when the source is run. 

Here comes the catch though. Since the decompressed file is around 18 MB, Cribl won’t be able to break the file into separate events later on in the pipeline you’ll be using, because by default, the maximum number of bytes in an event before it is flushed to the pipelines is set at 51200 bytes. Luckily, you can make custom event breaker rules where you can adjust the maximum size.

Find the Event Breaker Rules (under Processing > Knowledge). Either create a new Ruleset, or make a copy of the existing Ruleset “Cribl - Do Not Break Ruleset”. What we’re interested in is to adjust the Max event bytes size so the XML file in its entirety will be sent to the pipeline for processing.

So choose a value that’s the size of the file in bytes, or go all the way up to the maximum number of bytes an event can be for Cribl to handle (134217728 bytes).

Use the custom Event Breaker Ruleset in your Data source.

Now we’re able to get the compressed XML file from the website and send it to the pipeline where we’ll do some processing.

In the pipeline we’ll be separating the events we can identify with the event tags from the XML file. We’ll be doing this with the help of the XML Unroll Function. This function accepts a XML event with a set of elements, and converts the elements into individual events.

If we look at the XML file again, we’ll notice that the information we’re interested in in element event  is located as a child element under element minute_speed_and_flow_events which itself is a child element under element ndw:exchange which itself is a child element under element ndw:NdwMrm. And then you have your SOAP body and SOAP envelope.

With this information at hand, we can say that the information we want is located at

SOAP:Envelope\SOAP:Body\ndw:NdwMrm\minute_speed_and_flow_events\event

This is exactly what we’ll be using in the function XML Unroll. Well, we need to change it a little bit because we need to put a Regex expression in the function which describes the path to the array to unroll:

^SOAP:Envelope\.SOAP:Body\.ndw:NdwMrm\.minute_speed_and_flow_events\.event$

The Copy Elements Regex part is empty, because we don’t need anything to be copied into the separate events.

If this is our XML event we put into our pipeline (remember, it’s one big event, so the image is just a sample image)

the XML Unroll Function will make separate XML events and you’ll have something like this (with the Pretty Print option selected)

Each event will have an element measuring_point_id with respectively an element <lanelocation>, <avgspeed> or <flow>.

But we’re not done yet. In our workshop we didn’t want XML events to be sent to our external system, but rather have JSON events, since we were using the data the workshop participants were sending in a dashboard built around data in the JSON format.

Luckily, it’s rather simple to do this in Cribl, since there’s a Cribl expression available that just does that: parse an XML string and returns a JSON object: C.Text.parseXml()

We need to use this expression with the Eval Function to parse XML fields contained in our events.


With this in place the events will be available as JSON objects:

Now, our events are ready to be sent to an external system where the data can be used for whatever purpose.

In our case we used the data to show traffic near our office building:

docs.cribl.io/stream/expressions-text/#parse-xml

In this blog Data consultant Ramond Jaggessar explains how to transform XML data into JSON with Cribl.

Using Cribl to transform XML data to JSON

Het geven van trainingen vind ik een mooi onderdeel van mijn baan. Het is even uit de dagelijkse routine stappen om zo cursisten kennis bij te brengen over mijn vakgebied. Super leuk om over je werk te mogen vertellen, nieuwe mensen te ontmoeten en hen te helpen bij de uitdagingen die binnen hun bedrijf spelen. In deze blog deel ik graag mijn ervaringen met het geven van Splunk-trainingen, inclusief de voorbereiding, het ontwikkelen van oefenopdrachten met AI en natuurlijk het verzorgen van de training zelf.

Voorbereiding Splunk training
Bij CINQ bieden wij trainingen aan op alle niveaus van Splunk. Daarbij leveren wij maatwerk om zo op de behoeften van onze klanten in te spelen. Zodra CINQ een aanvraag ontvangt van onze partner of rechtstreeks van een klant, beginnen wij met het afstemmen van de training op hun specifieke wensen. Hierbij kijken wij niet alleen naar praktische zaken zoals datum en locatie, maar vooral naar de vraag van de klant: wie zijn de deelnemers en wat willen zij precies leren? 

Na het eerste contact starten wij met de voorbereiding van de training. De trainingen zijn meestal verdeeld over 2 tot 3 trainingsdagen, met steeds een week er tussen. Op deze manier krijgen de cursisten de kans om tussen de trainingsdagen door oefeningen te maken en worden zij niet in één dag overladen met theorie. De training zelf bestaat uit een combinatie van theorie en praktijk. Zo leggen wij bijvoorbeeld een Splunk-commando uit en laten de cursisten vervolgens een bijpassende oefenopdracht uitvoeren. Als de training op locatie bij de klant plaatsvindt, kunnen wij in overeenstemming (NDA) ook gebruikmaken van klantdata, hoewel werken met gegenereerde testdata altijd een mogelijkheid is.

Het maken van oefenopdrachten met AI:
Vaak gebruik ik AI-chatbots voor het maken van de oefenopdrachten. Dit bespaart tijd en biedt de mogelijkheid om een test set te personaliseren voor een specifiek bedrijf of branche. De opdrachten worden hierdoor begrijpelijker en leuker voor de cursisten. 

Voor mijn laatste training maakte ik gebruik van ChatGPT, maar Google Gemini of Microsoft CoPilot zouden ook gebruikt kunnen worden. Als voorbeeld moest ik het timechart- en timewrap-commando uitleggen aan een groep die werkzaam is voor een luchthaven. Uiteindelijk kwam ik tot de volgende invoer:

“Maak met SPL en het gentimes commando een testset aan data. Bij gentimes als start-365 als end=0 increment=1d. Doe vervolgens eval _time=starttime. Vervolgens maak met eval statements een ticket_price aan tussen de 200-205 waarbij de ticket_price langzaam afneemt, en geef gebruikmakend van random() 3 airlines. Kies daarna met een where clause 1 luchthaven, vervolgens maak een timechart met de gemiddelde ticket_price per maand en een timewrap per q.”

ChatGPT is helaas geen SplunkGPT*. Het heeft hulp nodig om een werkende Splunk query te fabriceren. Zo herkent het niet alle Splunk commando's of maakt het verkeerde aannames bij het schrijven ervan, waardoor de geleverde SPL code niet werkt. Daarom geef ik in bovenstaand voorbeeld zeer specifieke instructies, door de vraag zo gedetailleerd mogelijk te formuleren. Zo schrijf ik commando’s uit en geef ik in stappen de volgorde van de commando’s weer. De output van ChatGPT is een query die ik bijna rechtstreeks in Splunk kan gebruiken.

Waar ChatGPT de aanname doet dat comments met een # moeten beginnen is dat bij splunk met 3 backtics. Na deze aanpassing zal de query correct werken.

Door een deel van deze query aan de cursisten te verstrekken, kunnen gebruikers eerst een luchtvaartmaatschappij kiezen, vervolgens een timechart maken en deze uiteindelijk aanpassen naar een timewrap per kwartaal. Daarna kunnen ze onderzoeken wat er is gebeurd met de ticketprijzen in het afgelopen jaar.

*Bovenstaande is gemaakt met de gratis versie van ChatGPT gebaseerd op model 3.5. Met de betaalde versie van ChatGPT, 4.0 kun je ook custom GPT’s gebruiken. Dat zijn Chat GPT extensies, die zijn toegespitst op 1 specifieke functionaliteit. Zo zijn er een aantal Splunk GPT’s te vinden op de markt. Mijn ervaring is dat deze ietwat betere resultaten leveren dan de gratis variant, maar zeker niet perfect werken. De tip blijft om je vraag zo exact mogelijk te formuleren, om zo ruimte voor interpretatie en inbreng door chatGPT te verkleinen.

De training zelf:
Met het slidedeck en de testopdrachten gereed, is het tijd om de training te geven. Voordat de training begint ben ik al aanwezig op locatie om alles gereed te maken. Ik heet de cursisten één voor één welkom en tijdens een gezamenlijke kennismaking vraag ik de cursisten kort te vertellen wie zij zijn en wat zij persoonlijk uit de training willen halen. Zo kan ik een laatste afstemming doen en inschatten waar tijdens de training meer of minder aandacht aan besteed moet worden. 

Op de eerste dag, met name de ochtend van de training, ligt de focus meer op de theorie. Aan het einde van de dag geef ik vaak een huiswerkopdracht mee om de theorie in de praktijk te brengen. Daarnaast vraag ik de cursisten om na te denken over hun verwachtingen voor de volgende dagen. Tussen de trainingsdagen door bel ik meestal met onze contactpersoon om feedback te verzamelen die ik kan gebruiken voor de laatste trainingsdagen. 

Op de tweede en/of laatste dag wordt er meer aandacht besteed aan praktische toepassingen. Vaak staat er een praktijkopdracht op het programma en is er extra ruimte voor vragen en specifieke situaties van de klant. 
We sluiten gezamenlijk af met een evaluatie en de cursisten ontvangen een certificaat van deelname.

Komende maand schrijf ik nog een blog over hoe je Splunk Dashboards kan maken met ChatGPT en hoe je bestaande classic XML-dashboards mooier kan maken. Houdt de blogs van CINQ dan ook in de gaten.

Tom verteld over het geven van trainingen via CINQ ICT

Trainingen geven

About a year ago I wrote a blog with the title ‘How to write a simple IntelliJ plugin’. In the previous blog I explained why I wrote the plugin and which steps I had to take. Furthermore you will also read that I set out to create a proper plugin. That is a plugin that can easily be installed by downloading it from the Jetbrains Marketplace. This turned out to be much harder than I expected, so that is why I settled for a live plugin last year. The blog ends with the suggestion that I will write a proper plugin in the future and will blog about it. Well the future is now, as this blog will be about creating this proper plugin. 

The main reason to pick up this pet project again is the fact that I will be giving my talk ‘Improving your skills with the debugger’ at JavaLand. The old plugin is part of this talk, but I always try to update my talk with the latest and greatest. So I decided it was time to finally create a proper plugin. 

The difference between the previous and the current title is exactly two words. The word ‘write’ became ‘create’ and ‘simple’ became ‘proper’. I talked enough about the second difference, so let’s explain the first. The meat of the previous blog was how to write (or code) a plugin. This blog will focus more on how to get this plugin in the JetBrains marketplace. So it also covers the process after writing the plugin. 

In the previous blog I wrote that I tried to create a proper plugin, so my first step was to open this old project and to make sure that everything still functioned. The previous project was around a year old and to my surprise I could not get it working again. Software decay/rot is real! I spent a few hours before I decided to throw the towel. I solved this issue by starting with a clean slate. Jetbrains provides a template plugin repository (link) that you can fork. So I did this and added my code from the previous project. The code compiled again, so the problem was solved!

The first thing I noticed when using the provided template was the feature that one can start a completely new instance of IntelliJ with your plugin pre-installed (see Image 1). This was something I did not notice the previous time I tried to create a plugin. A very useful feature which lets you properly manually test your plugin before you upload it to the marketplace. 

Image 1 - Run Plugin starts a new instance of the IDE with your plugin pre-installed.

The observant reader noticed the word ‘manually’ in the previous sentence. This is a fine start, but in the end we need automated tests as well. It turns out that it is pretty hard. The documentation gives a few examples, but I still spent hours and hours before I got a green unit test. In those hours I had to figure out why a part of my test context was not initialized properly. I spent a lot of time in the source code of IntelliJ to find clues. In the end it turned out to be a dependency problem. I had to specify that my plugin was dependent on the Java features of IntelliJ. For people with the same problem Image 2 shows where to add dependencies. After addressing this omission, things went pretty smooth and I had a lovely green unit test in the end.

Image 2 - This is where one adds dependencies.

With this test in place, I could finally do some refactorings and remove some unnecessary boilerplate from the template plugin project. Furthermore I found a bug while manually testing the plugin. So I updated the test (and fixed the bug) to prevent this ever happening again. As far as I was concerned the plugin was ready to share with the world.

The first step in publishing the plugin is signing it with a private key. The Jetbrains marketplace will use the public key to see if everything is in order. You only have to create a private-public key pair and the template takes care of the heavy lifting after you add a few environment variables. This is a pretty standard procedure for app (or plugin) stores. 

The next step is uploading the plugin to the marketplace. Again a straightforward process. You can choose between a manual upload or an upload via the Gradle scripts in the template. In the former case you can upload your .jar file in your browser. In the latter case you first need to generate a token in your Jetbrains account. The next step is to add this token as an environment variable. You can run the Gradle scripts locally or you can use the included GitHub Actions pipeline. 

The last step is the most difficult one. You have to wait till the people of the Jetbrains Marketplace approve your plugin. This process takes up to two business days. Luckily I had something to do in the meantime, because the dependabot found a lot of dependencies to upgrade. In case you do not know what dependabot is: it is a GitHub bot that creates pull requests in your project whenever it finds a newer version of a dependency.

I am really excited to have my first plugin published on the Jetbrains Marketplace! I learned a lot in the process of creating, testing and publishing the plugin. Normally I use Maven as my go-to buildtool. So it was a nice change to be forced to use Gradle. Secondly, I have never used GitHub Actions before and it is nice to see it in action (pun intended). Thirdly, I had a reason to browse the IntelliJ codebase, which was interesting. Finally, it gave me an excuse to write a new blogpost. 

The plugin can be found here:
https://plugins.jetbrains.com/plugin/23796-log-selection-with-breakpoint

Please visit it, as I've put in extra effort to create an animated gif to demonstrate what the plugin does.
The source code can be found here:
https://github.com/BoukeNijhuis/breakpoint-log-selection

So, there is only one question left to answer: how will I continue this blog series? Good question! My intention is to add a feature to the plugin that enables you to change the hard-coded log expression. However, to do so, I need a UI where you can edit the current expression. So, that sounds like a lot of work. Till next year!

Image 3 The plugin can be found on the IntelliJ marketplace

In this blog Bouke Nijhuis explains how he created a proper plugin for IntelliJ and how he published it on the IntelliJ Marketplace.

How to create a proper IntelliJ plugin

Vakmensen, dat zijn we. En wat we doen op het gebied van informatie- en communicatietechnologie helpt organisaties slim verder. Effectief en meetbaar bovendien. Aangenaam, CINQ. Specialisten in Data, DevOps en Development. Wij geloven in specialisten, vandaar de driedeling Data, DevOps en Development binnen ons bedrijf. Zo zorgen we dat jij excelleert, want je werkt het best waar je je het meest thuis voelt. Logisch, toch?

cinq_logo.png

cinq_logo_square.png

CINQ ICT

We delen graag onze kennis over Data, DevOps en Development met je. Op ons blog lees je tips en tricks over bijvoorbeeld Splunk, Docker, Kubernetes en Java.

Onze laatste blogs