Nicklas Wiegandt

Integration Testing Spring AI MCP Server

2026-01-04T13:00:00-06:00

While working on my ZDF Mediathek MCP Server, I noticed a lack of good resources on how to properly integration test a Spring AI MCP Server. Since I usually follow a Test-Driven Development (TDD) approach, this was a bit of a hurdle.

I wanted to test my MCP tools integratively, meaning I wanted to ensure that the part I’m testing is actually called via the Model Context Protocol.

The Approach

My solution involves using the Spring AI MCP Client within the test to establish a connection to the MCP Server that is started via @SpringBootTest. This allows me to simulate a real client interaction.

To make this work, I first needed to add the MCP Client dependency to my build.gradle.kts:

testImplementation("org.springframework.ai:spring-ai-starter-mcp-client-webflux")

The Integration Test

Here is an example based on my SearchContentServiceIT, which tests the search_content tool.

The key part is the setUp and tearDown methods. In setUp, I initialize the mcpClient so that it connects to the server running on the random local port provided by @SpringBootTest.

@SpringBootTest(
    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
    properties = [
        "spring.ai.mcp.client.enabled=true",
        "spring.ai.mcp.client.type=async",
        // ... other properties
    ]
)
@EnableWireMock(
    ConfigureWireMock(
        baseUrlProperties = ["zdf.url"]
    )
)
class SearchContentServiceIT {
    @LocalServerPort
    private var port: Int = 0

    @Autowired
    private lateinit var webClientBuilder: WebClient.Builder

    private lateinit var mcpClient: McpAsyncClient

    @BeforeEach
    fun setUp() {
        val transport = WebClientStreamableHttpTransport.builder(
            webClientBuilder.baseUrl("http://localhost:$port")
        )
            .endpoint("/")
            .build()

        mcpClient = McpClient.async(transport).build()
        mcpClient.initialize().block()
    }

    @AfterEach
    fun tearDown() {
        mcpClient.closeGracefully().block()
    }

    // ... tests
}

I use WireMock to mock the actual external API (in this case, the ZDF API) that my MCP tool talks to. This keeps the test isolated from the real backend while testing the full MCP flow.

Calling the Tool

In the test method itself, I can now use the mcpClient to call the tool and verify the result.

    @Test
    fun `search_content valid Query returns expected result`() {
        // ... setup expectations and WireMock stubs ...

        // when
        val response = parseTextContent(
            mcpClient.callTool(
                McpSchema.CallToolRequest(
                    "search_content",
                    mapOf<String, String>(
                        Pair("query", "Tagesschau"),
                        Pair("limit", "2")
                    )
                )
            )
        )

        // then
        assertThat(response).usingRecursiveComparison().isEqualTo(expectedResponse)
    }

Parsing the Response

One interesting helper method I created is parseTextContent. It helps to convert the text content from the MCP Client’s response back into a typed object using the Jackson ObjectMapper. This makes assertions much easier.

    private fun parseTextContent(result: Mono<McpSchema.CallToolResult>): ZdfSearchResponse {
        return objectMapper.readValue<ZdfSearchResponse>(
            (result.block()!!
                .content()
                .first() as McpSchema.TextContent).text()
        )
    }

This approach allows me to test my MCP tools end-to-end within the Spring context, ensuring that the MCP layer, the tool implementation, and the integration with external services (mocked) work together as expected.

Creating a new website Theme with the help of GenerativeAI

2026-01-04T05:00:00-06:00

I decided it was time to give my website a fresh look. But instead of starting from scratch or browsing endless theme galleries, I turned to Generative AI for help.

The Idea Generation

First, I used Perplexity Pro to generate a variety of design concepts. I asked it to create 20 distinct, responsive, and theme-aware single-page HTML design proposals for a personal portfolio and blog of a Software Architect. I specified that the designs should range from standard to minimalist styles and utilize tools like iconoir if needed.

Perplexity provided me with 20 different design proposals, each as a single HTML file. This was a fantastic way to quickly visualize different directions I could take.

Refining the Selection

From these 20 ideas, I selected the four that appealed to me the most. But a static HTML file is just the beginning. To take it further, I used GitHub Copilot with the Claude Sonnet 4.5 and Gemini 3 Pro models. I asked Copilot to create example themes based on these four selected designs.

I then iterated on these themes, refining them further to better suit my content and personal style.

The Final Implementation

After playing around with the four refined themes, I picked the winner: the "Hero Timeline Theme".

To turn this design into a fully functional Jekyll theme, I once again relied on GitHub Copilot, specifically using the Gemini 3 Pro model. Copilot helped me convert the HTML and CSS into a proper Jekyll theme structure, creating layouts, includes, and assets. It also assisted in migrating my existing content and ensuring that features like the blog and tags worked seamlessly with the new design.

The result is what you are seeing right now! A modern, responsive website created with the power of Generative AI.

Skip the first two lines of a file in Apache Camel

2023-02-09T14:00:00-06:00

Apache Camel is a popular open-source framework for integrating various systems and services. It provides a variety of components and tools to make it easier to integrate different systems, such as file systems, databases, and web services.

However, in some cases, it might be necessary to skip some lines in a file while processing it with Apache Camel. For instance, you might have a file that has some metadata in the first two lines, and you only want to process the actual data from the file.

In this article, I’ll show you how to skip the first two lines of a file in Apache Camel. The solution can be applied to any type of message that’s split by the split component, not just files.

The Problem

When you’re processing a file in Apache Camel, it’s possible to use the split component to split the file into separate messages, one message per line. However, if you want to skip some lines, such as the first two lines, you need a way to filter out those messages before they’re processed.

The Solution

Apache Camel provides a filter component that allows you to filter out messages based on a condition. The condition can be specified using the simple language, which provides a simple expression language for filtering messages.

To skip the first two lines of a file, we can use the filter component and check the value of the CamelSplitIndex property. This property is set by the split component and indicates the current index of the message in the split list.

Here’s an example of how to skip the first two lines of a file in Apache Camel:

from("file:input?noop=true")
.split().tokenize("\n")
.filter(simple("${exchangeProperty.CamelSplitIndex} > 1"))
.to("file:output");

In this example, we start by reading a file from the input directory using the file component. The noop option is set to true, which means that Apache Camel will not delete the original file after processing it.

Next, we use the split component to split the file into separate messages, one message per line. The tokenize option is set to "\n", which means that the file will be split on newline characters.

After that, we use the filter component to filter out messages that have an index lower than or equal to 1. This will effectively skip the first two lines of the file.

Finally, we use the to component to write the filtered messages to the output directory.

Conclusion

In this article, I showed you how to skip the first two lines of a file in Apache Camel. By using the filter component and checking the value of the CamelSplitIndex property, you can easily filter out the unwanted lines in a file. With Apache Camel, it’s possible to solve a variety of integration problems, and this is just one of the many examples.

This article was created with the help of ChatGPT, an AI model by OpenAI.

Using Docker in jenkins with jenkins Docker agent

2021-06-06T03:00:00-05:00

Getting Jenkins CI to build Docker container with a jenkins Docker agent

The problem

Running Jenkins CI agents as containers is a nice thing. However it can be a hassle if you want to build a container inside the containerized docker agent. Using the standard Jenkins agent container will result in an error telling you that the Docker binary is not found.

The solution

The default Jenkins agent container doesn’t contain the Docker binaries. 😔

But the Jenkins JNLP agent Docker container does! 😀

Unfortunately the image is missing any description and finding any documentation is hard. You can neither view the Dockerfile nor is the source linked. But in the GitHub repository for the JNLP Agents is a subdirectory called docker in which you can find this Dockerfile. This seems to be the source for the linked image. One can see that the Docker binary is getting installed on build time.

In order to use the agent go to your Jenkins server settings and click on Manage Nodes and Clouds → Configure Clouds.

If you haven’t already set your Docker settings:
Name: docker
Docker Host URI: unix:///var/run/docker.sock

The Jenkins Docker setting

Then open the Docker Agent templates section.
Change the Docker Image to: jenkins/jnlp-agent-docker

The Jenkins agent template settings

After that open the container settings and set the following:
User: root
Volumes: /var/run/docker.sock:/var/run/docker.sock

The Jenkins agent template container settings

Thats it. Happy dockerizing 🙂

Docker Compose log aggregation using Grafana Loki and Fluent Bit

2020-12-20T15:00:00-06:00

How to use Grafana Loki for docker compose log aggregation using Fluent Bit.

Recently Alex, my co-maintainer of MediathekView, asked me to build a Docker Compose file to view the MServer logs with Grafana Loki. I chose Fluent Bit as log proccessor and forwarder becuase Docker Compose can use the fluentd logging driver out of the box.

This does not seem particularly complex at first. However, there are some pitfalls hidden due to missing or outdated information.

The solution

Loki, Grafana and Fluent Bit

The Docker Compose part for Loki and Grafana is straightforward:

docker-compose-loki.yml

  version: "3.3"
  networks:
    loki:
      driver: bridge

  services:
    loki:
      image: grafana/loki:2.0.0
      container_name: loki
      ports:
        - "3100:3100"
      command: -config.file=/etc/loki/local-config.yaml
      networks:
        - loki

    grafana:
      image: grafana/grafana:latest
      container_name: grafana
      ports:
        - "3000:3000"
      networks:
        - loki

The fluent bit part is also straightforward, but unlike the sample Fluent Bit Docker Compose file, port 24224 is exposed. The port is required by the fluentd docker logging driver.

docker-compose-loki.yml

  fluent-bit:
    image: fluent/fluent-bit
    container_name: fluentbit
    ports:
        - "24224:24224"
        - "24224:24224/udp"
    volumes:
      - .docker/logging/fluent-bit.conf:/fluent-bit/etc/fluent-bit.conf
    networks:
      - loki

The two compose configuration can then be combined into one single compose file:

docker-compose-loki.yml

version: "3.3"
networks:
  loki:
    driver: bridge

services:
  loki:
    image: grafana/loki:2.0.0
    container_name: loki
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    networks:
      - loki

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    networks:
      - loki

  fluent-bit:
    image: fluent/fluent-bit
    container_name: fluentbit
    ports:
        - "24224:24224"
        - "24224:24224/udp"
    volumes:
      - .docker/logging/fluent-bit.conf:/fluent-bit/etc/fluent-bit.conf
    networks:
      - loki

Fluent Bit configuration

The configuration of Fluent Bit is almost identically to the example in the Fluent Bit documentation, but one important change must be made.

The label $sub['stream'] of the example isn’t applicable for Docker Compose logs. An example for a log line looks like this:

{"container_id":"05070542e00a616589a3671404d34fe7374f3b6f08ef6f71431acc42fbfa8675","container_name":"/mserver_mserver_1","source":"stdout","log":"[INFO ] [EtmMonitor] Shutting down JETM."}

Instead of $sub['stream'] I defined $container_id, $container_name and $source as labels.

fluent-bit.conf

[SERVICE]
    Flush        1
    Daemon       Off
    Log_Level    info

[INPUT]
    Name   forward
    Listen 0.0.0.0
    Port   24224

[Output]
    Name loki
    Match *
    host loki
    port 3100
    labels job=mserver,$container_id,$container_name,$source
    line_format json

Using the fluentd docker logging driver

To use the fluentd docker logging driver in conjunction with other Docker Compose this snippet can be used:

docker-compose.yml

    logging:
      driver: "fluentd"
      options:
        fluentd-address: localhost:24224
        tag: httpd.access

Sending the logs of nginx to Loki may look like this: .docker-compose.yml

version: "3.3"
services:
  nginx:
    image: nginx
    volumes:
    - ./templates:/etc/nginx/templates
    ports:
    - "8080:80"
    environment:
    - NGINX_HOST=foobar.com
    - NGINX_PORT=80
    logging:
      driver: "fluentd"
      options:
        fluentd-address: localhost:24224
        tag: httpd.access

Grafana Loki show only Log message

When viewing the logs in the Grafana exploring view or with the Dashboard Log Panel, the individual lines are quite ugly. The entire json message is displayed, which quickly becomes very confusing. In order to get the log messages into a more readable format, one can use a new feature of Loki version 2.0: line_format

An example query for the container mserver_mserver_1:

{container_name="/mserver_mserver_1"} | json | line_format "{{.log}}"

Links

Some useful Links:

Thanks to Daniel for his review of this post

Use K3OS system Traefik with Let’s Encrypt

2020-08-02T07:00:00-05:00

How to use K3OS system Traefik with Let’s Encrypt.

The problem

K3OS comes with a system Traefik. Nice so we can use it to route our services and give them with Let’s Encrypt HTTPS. Yes!

But how to configure it to do what we want? There is a configuration file: /var/lib/rancher/k3s/server/manifests/traefik.yaml

Seems to work pretty well so where is the problem? If you reboot your server or, like in my case your provider restarts your server, all Traefik configuration is lost.

The solution

K3OS has some persistent directories and /var/lib/rancher/k3s/server/manifests isn’t one. Ok but the documentation says that you can write manifests with the configuration key write_files. But there’s another stumbling block! Per default K3OS overwrites the Traefik configuration on each boot.

So here is the solution, you need to add this to your K3OS configuration:

/var/lib/rancher/k3os/config.yaml

  k3s_args:
  - server
  - "--no-deploy=traefik"

Now don’t forget to write the Traefik configuration with write_files:

/var/lib/rancher/k3os/config.yaml

write_files:
- content: |-
    apiVersion: helm.cattle.io/v1
    kind: HelmChart
    metadata:
      name: traefik
      namespace: kube-system
    spec:
      chart: https://%{KUBERNETES_API}%/static/charts/traefik-1.81.0.tgz
      set:
        rbac.enabled: "true"
        ssl.enabled: "true"
        ssl.enforced: "true"
        acme.enabled: "true"
        acme.challengeType: "tls-alpn-01"
        acme.email: "admin@yourdomain.com"
        acme.staging: "false"
        metrics.prometheus.enabled: "true"
        kubernetes.ingressEndpoint.useDefaultPublishedService: "true"
        image: "rancher/library-traefik"
  owner: root
  path: /var/lib/rancher/k3s/server/manifests/traefik.yaml
  permissions: '0755'

A complete configuration could look like this:

/var/lib/rancher/k3os/config.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
k3os:
  k3s_args:
  - server
  - "--no-deploy=traefik"
sshAuthorizedKeys:
- github:yourGithubUserName
write_files:
- content: |-
    apiVersion: helm.cattle.io/v1
    kind: HelmChart
    metadata:
      name: traefik
      namespace: kube-system
    spec:
      chart: https://%{KUBERNETES_API}%/static/charts/traefik-1.81.0.tgz
      set:
        rbac.enabled: "true"
        ssl.enabled: "true"
        ssl.enforced: "true"
        acme.enabled: "true"
        acme.challengeType: "tls-alpn-01"
        acme.email: "admin@yourdomain.com"
        acme.staging: "false"
        metrics.prometheus.enabled: "true"
        kubernetes.ingressEndpoint.useDefaultPublishedService: "true"
        image: "rancher/library-traefik"
  owner: root
  path: /var/lib/rancher/k3s/server/manifests/traefik.yaml
  permissions: '0755'

How to use it for a container

In case you are reading this and do not know how to use Traefik with your container now, here is how it works:

It’s super simple! :) Of course your domain has to be configured to point to your server for all domains you wan’t to use. Your Traefik configuration has to be correct to. How to do this is documented in the Traefik documentation and there is a example in the solution above. If these basic conditions are fulfilled it is super easy.

To instruct Traefik to route a subdomain with HTTPS to a service you just need to create a Ingress for your service:

---
kind: Ingress
apiVersion: extensions/v1beta1
metadata:
  name: myservice-ingress
  namespace: myservice

spec:
  rules:
    - host: service.mydoma.in
      http:
        paths:
          - path: /
            backend:
              serviceName: my-service
              servicePort: 8080

A complete service description inclunding Ingress could look like this:

README.md view raw

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
apiVersion: v1
kind: Namespace
metadata:
  name: mediathekview
---
apiVersion: v1
kind: Service
metadata:
  name: zapp-backend
  namespace: mediathekview

spec:
  ports:
    - name: http
      protocol: TCP
      port: 3000
  selector:
    app: zapp-backend
---
kind: Deployment
apiVersion: apps/v1
metadata:
  namespace: mediathekview
  name: zapp-backend
  labels:
    app: zapp-backend

spec:
  replicas: 1
  selector:
    matchLabels:
      app: zapp-backend
  template:
    metadata:
      labels:
        app: zapp-backend
    spec:
      containers:
        - name: zapp-backend
          image: mediathekview/zapp-backend
          ports:
            - name: web
              containerPort: 3000
---
kind: Ingress
apiVersion: extensions/v1beta1
metadata:
  name: zapp-backend-ingress
  namespace: mediathekview

spec:
  rules:
    - host: api.zapp.mediathekview.de
      http:
        paths:
          - path: /
            backend:
              serviceName: zapp-backend
              servicePort: 3000

Elastic Stack with Fluent Bit Helm for Kubernetes container logs

2020-08-01T13:15:00-05:00

How to install Elastic Stack with Helm and get all Kubernetes container logs in to it with Fluent Bit.

The problem

The helm chart for Elastic Stack (stable/elastic-stack) seems to be pretty easy right? Yeah it is but if you install it with Fluent Bit activated it tries to find Fluentd and even if you install Fluentd too it can’t find it. And to get it even worse Fluentd can’t find Elasticsearch. But why?

Fluent Bit uses the wrong hostname of Fluentd and Fluentd uses the wrong hostname of Elasticsearch.

The solution

Fortunally Fluent Bit don’t need Fluentd to send its logs to Elasticsearch. So we just need to configure Fluent Bit to communicate with Elasticsearch and use the right hostname. The default helm values already include the right Elasticsearch hostname. Why it isn’t already set for Fluentd and Fluent Bit? I don’t know.

Here is my values file to get it working:

elastic-stack-fluentbit-values.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
elasticsearch:
  enabled: true

kibana:
  enabled: true
  env:
    ELASTICSEARCH_HOSTS: http://{{ .Release.Name }}-elasticsearch-client:9200

logstash:
  enabled: false
  # elasticsearch:
  #   host: elastic-stack-elasticsearch-client

filebeat:
  enabled: false
  # config:
  #   output.file.enabled: false
  #   output.logstash:
  #     hosts: ["{{ .Release.Name }}-logstash:5044"]
  # indexTemplateLoad:
  #   - {{ .Release.Name }}-elasticsearch-client:9200

fluentd:
  enabled: false

fluent-bit:
  enabled: true
  backend:
    type: es
    es:
      host: {{ .Release.Name }}-elasticsearch-client

fluentd-elasticsearch:
  enabled: false

nginx-ldapauth-proxy:
  enabled: false
elasticsearch-curator:
  enabled: false

elasticsearch-exporter:
  enabled: false

About this blog

2020-07-31T13:15:00-05:00

My first post on my new blog. This posts is about the blog itself and how it’s made.

I created this blog to write about DevOp’s things that keep me occupied. These will mainly be solutions to problems for which I had to search and try around for a long time. With this I want to achieve that others do not have to search so long for the right solution. Maybe, if I find time and motivation, I will also write articles about my work on MediathekView. And maybe I will also write articles about frameworks & technologies I am currently busy oneself with. And maybe I write articles about frameworks and technologies I’m currently working with.

The blog itself is made with Jekyll and AsciiDoc. It’s hosted on GitHub where you can also find the source. Because this don’t allow to send E-Mails on server side, I created an AWS Lambda for the contact form.

This is the source of my contact form lambda:

lambda_function.py view raw

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
from __future__ import print_function
from botocore.exceptions import ClientError
from urllib.request import urlopen
import boto3
import json
import requests

def lambda_handler(event, context):
    if "g-recaptcha-response" in event and "mail" in event and "text" in event:
        success = checkRecaptcha(event["g-recaptcha-response"])
    else:
        success = False

    if success:
        send_email(event["mail"],event["text"])
    else:
        print("RECaptcha failed!")

    return {
        "location": event["referer"]
    }

def checkRecaptcha(captchaCode):
    requestData = { "secret": "mySecret", "response": captchaCode }
    data = requests.post("https://www.google.com/recaptcha/api/siteverify", data=requestData)
    result = data.json()
    return result.get('success', None)

def send_email(userMail, content):
    # Replace sender@example.com with your "From" address.
    # This address must be verified with Amazon SES.
    SENDER = "My Sender "

    # Replace recipient@example.com with a "To" address. If your account
    # is still in the sandbox, this address must be verified.
    RECIPIENT = "recipient@my.domain"

    # If necessary, replace us-west-2 with the AWS Region you're using for Amazon SES.
    AWS_REGION = "eu-west-1"

    # The subject line for the email.
    SUBJECT = "A user has sent you a message"

    # The character encoding for the email.
    CHARSET = "UTF-8"

    # Create a new SES resource and specify a region.
    client = boto3.client('ses',region_name=AWS_REGION)

    # Try to send the email.
    try:
        #Provide the contents of the email.
        response = client.send_email(
            Destination={
                'ToAddresses': [
                    RECIPIENT
                ]
            },
            ReplyToAddresses=[
                userMail,
            ],
            Message={
                'Body': {
                    'Text': {
                        'Charset': CHARSET,
                        'Data': content,
                    },
                },
                'Subject': {
                    'Charset': CHARSET,
                    'Data': SUBJECT,
                },
            },
            Source=SENDER,
        )
    # Display an error if something goes wrong.
    except ClientError as e:
        print(e.response['Error']['Message'])
    else:
        print("Email sent! Message ID:"),
        print(response['MessageId'])

Because the HTML form sends it’s data as www-form-urlencoded the following API gateway integration request mapping template is needed:

api_gateway_mapping_template.vtl view raw

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
## convert HTML POST data or HTTP GET query string to JSON

## get the raw post data from the AWS built-in variable and give it a nicer name
#if ($context.httpMethod == "POST")
 #set($rawAPIData = $input.path("$"))
#elseif ($context.httpMethod == "GET")
 #set($rawAPIData = $input.params().querystring)
 #set($rawAPIData = $rawAPIData.toString())
 #set($rawAPIDataLength = $rawAPIData.length() - 1)
 #set($rawAPIData = $rawAPIData.substring(1, $rawAPIDataLength))
 #set($rawAPIData = $rawAPIData.replace(", ", "&"))
#else
 #set($rawAPIData = "")
#end

## first we get the number of "&" in the string, this tells us if there is more than one key value pair
#set($countAmpersands = $rawAPIData.length() - $rawAPIData.replace("&", "").length())

## if there are no "&" at all then we have only one key value pair.
## we append an ampersand to the string so that we can tokenise it the same way as multiple kv pairs.
## the "empty" kv pair to the right of the ampersand will be ignored anyway.
#if ($countAmpersands == 0)
 #set($rawPostData = $rawAPIData + "&")
#end

## now we tokenise using the ampersand(s)
#set($tokenisedAmpersand = $rawAPIData.split("&"))

## we set up a variable to hold the valid key value pairs
#set($tokenisedEquals = [])

## now we set up a loop to find the valid key value pairs, which must contain only one "="
#foreach( $kvPair in $tokenisedAmpersand )
 #set($countEquals = $kvPair.length() - $kvPair.replace("=", "").length())
 #if ($countEquals == 1)
  #set($kvTokenised = $kvPair.split("="))
  #if ($kvTokenised[0].length() > 0)
   ## we found a valid key value pair. add it to the list.
   #set($devNull = $tokenisedEquals.add($kvPair))
  #end
 #end
#end

## next we set up our loop inside the output structure "{" and "}"
{
  "referer" : "$input.params('referer')",
#foreach( $kvPair in $tokenisedEquals )
  ## finally we output the JSON for this pair and append a comma if this isn't the last pair
  #set($kvTokenised = $kvPair.split("="))
 "$util.urlDecode($kvTokenised[0])" : #if($kvTokenised[1].length() > 0)"$util.urlDecode($kvTokenised[1])"#{else}""#end#if( $foreach.hasNext ),#end
#end
}