Clone the Repository

The first step to getting started is to clone the source repositories, which include both the Flutter application and the Python backend. Open your terminal and execute the following command:

git clone https://github.com/andibaso/todoist-flutter.git
git clone https://github.com/andibaso/todoist-python.git

Step 2: Run the Application

With the repositories cloned, navigate into your Flutter project’s directory and set up the environment. Ensure you have both Flutter and Dart installed on your machine. Enter the following commands:

cd todoist-flutter
flutter pub get
flutter run

Additionally, start your Python backend as follows:

cd ../todoist-python
pip install -r requirements.txt
python manage.py runserver

Make sure that all the necessary packages are installed both for Flutter and Python to ensure seamless interaction between the mobile app and its backend.

Add New Relic Integration into Mobile

Now that your application is up and running, it’s time to integrate New Relic for monitoring. New Relic allows you to gain insights into your application’s performance by offering various metrics and visualizations.

1. Sign Up/In at New Relic: If you haven’t already, create an account at New Relic.

2. Generate API Keys: Navigate to ‘Account Settings’ and generate your API key needed for integration.

3. Install New Relic Mobile Monitoring Library: Add the New Relic Flutter package to your pubspec.yaml in your Flutter project:

  dependencies:
    newrelic_flutter_agent: ^1.0.0

Run flutter pub get to install the package.

1. Modify Main Entry Point: Edit your main.dart entry point to initialize New Relic:

  import 'package:flutter/material.dart';
  import 'package:newrelic_flutter_agent/newrelic_flutter_agent.dart';
  
  void main() {
    NewRelic.init('<your-api-key>');
    runApp(MyApp());
  }

Replace <your-api-key> with your actual New Relic API Key.

1. Add Custom Metrics and Events: Utilize the New Relic API to record custom events, errors, and performance metrics throughout the application lifecycle as needed.

Step 4: Monitoring Result with New Relic One

With the integration complete, it’s time to start monitoring your application performance using New Relic One:

1. Access New Relic One Dashboard: Navigate to the New Relic One dashboard and locate your application.

2. Observe Real-time Metrics: Analyze metrics such as app load time, error rates, throughput, and memory usage which will be visible within the dashboard.

3. Set Up Alerts: Configure alerts to notify you of critical conditions or thresholds, ensuring proactive management of your app’s health.

4. Explore Reports and Insights: Dive into detailed reports and explore various insights to optimize the performance and reliability of your Flutter application.

The integration of New Relic provides invaluable data points that contribute to better decision-making concerning optimizations and user experience improvements.

Mobile monitoring is crucial and New Relic offers a robust solution to get clarity on app performance straight to your fingertips. By following these steps, you can enhance your monitoring setup quickly and efficiently, ensuring that your users receive the best possible experience!

Configure Your New Relic License and User Key

To initiate monitoring with New Relic, commence by setting up your account credentials. Execute the following commands to export your account ID, license key, region, and user key:

export NR_ACCOUNT_ID=XXXXXXX
export NR_LICENSE_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXFFFFNRAL
export NR_REGION=US
export NR_USER_KEY=XXXX-XXXXXXXXXXXXXXXXXXXXXXXXXXX

Device Monitoring

Step 1: Install Docker Dependencies

Begin by installing Docker dependencies needed for network monitoring. Add Docker’s official GPG key and set up the repository with these commands:

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Step 2: Install jq

jq is a lightweight and flexible command-line JSON processor. Install it using:

sudo echo "deb http://us.archive.ubuntu.com/ubuntu vivid main universe" >> /etc/apt/sources.list
sudo apt-get update
sudo apt-get install jq -y

Step 3: Configure Docker

Adjust your Docker settings for optimal performance:

sudo usermod -aG docker $USER
sudo systemctl start docker
sudo chmod 666 /var/run/docker.sock
docker swarm init

Step 4: Create Docker Network

Create a Docker network to simulate devices and connect them effortlessly:

docker network create -d overlay --subnet=10.10.0.0/24 --attachable testnet

Step 5: Simulate Devices

Use Docker containers to simulate three network devices. Download and run preconfigured images using the following commands:

docker run -d --name=cisco-router --restart=always --network=testnet --privileged -v /:/rootfs:ro -v /etc/localtime:/etc/localtime:ro -v ./files/cisco-router:/usr/local/snmpsim/data tandrup/snmpsim
docker run -d --name=cisco-switch --restart=always --network=testnet --privileged -v /:/rootfs:ro -v /etc/localtime:/etc/localtime:ro -v ./files/cisco-switch:/usr/local/snmpsim/data tandrup/snmpsim
docker run -d --name=linksys-router --restart=always --network=testnet --privileged -v /:/rootfs:ro -v /etc/localtime:/etc/localtime:ro -v ./files/linksys-router:/usr/local/snmpsim/data tandrup/snmpsim

Step 6: Inspect Your Created Network

Verify the configuration of your Docker network:

docker network inspect testnet

Step 7: Create SNMP Base Configuration

Utilize the ktranslate Docker image to set up your initial SNMP base configuration:

docker pull kentik/ktranslate:v2
id=$(docker create kentik/ktranslate:v2)
docker cp $id:/etc/ktranslate/snmp-base.yaml .
docker rm -v $id
chmod 646 snmp-base.yaml

Step 8: Inspect the Base Configuration

Check the configuration file to ensure it meets your requirements:

vi snmp-base.yml

Step 9: Run Discovery Profile

Initiate a discovery operation in your network:

docker run -ti --name ktranslate-discovery --rm --net=testnet \
  --user `id -u`:`id -g` \
  -v `pwd`/snmp-base.yaml:/snmp-base.yaml \
  kentik/ktranslate:v2 \
  -snmp /snmp-base.yaml \
  -log_level info \
  -snmp_discovery=true

SStep 10: Running the ktranslate Agent*

Now it’s time to run the ktranslate agent to collect and send SNMP data to New Relic. Use the following command, which configures various parameters such as compression, logging, and data formatting:

docker run -d --name ksnmp --restart unless-stopped --net=testnet \
  -v `pwd`/snmp-base.yaml:/snmp-base.yaml \
  -e NEW_RELIC_API_KEY=$NR_LICENSE_KEY \
  kentik/ktranslate:v2 \
    -snmp /snmp-base.yaml \
    -compression=gzip \
    -sinks=new_relic \
    -nr_account_id=$NR_ACCOUNT_ID \
    -log_level=info \
    -metrics=jchf \
    -tee_logs=true \
    -max_flows_per_message=100 \
    -listen=0.0.0.0:8183 \
    -metalisten=0.0.0.0:8184 \
    -format=new_relic_metric \
    -nr_region=$NR_REGION \
    -service_name=ksnmp

**Step 11 : Inspect the logs to ensure that everything is functioning correctly: **

docker container logs ksnmp -f

Network Flow Monitoring

**Step 1: Install ktranslate agent ** To set up network flow monitoring, run another ktranslate container specifically configured for handling network flow data:

docker run -d --name knetflow --restart unless-stopped --net=testnet \
  -v `pwd`/snmp-base.yaml:/snmp-base.yaml \
  -e NEW_RELIC_API_KEY=$NR_LICENSE_KEY \
  kentik/ktranslate:v2 \
    -snmp /snmp-base.yaml \
    -nr_account_id=$NR_ACCOUNT_ID \
    -metrics=jchf \
    -log_level=debug \
    -tee_logs=true \
    -flow_only=true \
    -nf.source=netflow5 \
    -listen=0.0.0.0:8283 \
    -metalisten=0.0.0.0:8284 \
    -nr_region=$NR_REGION \
    nr1.flow

Step 2: Inspect your network and find your flow monitoring agent address

Take a moment to inspect your Docker network setup again:

docker network inspect testnet

Step 3: Simulate Network Flow

Launch a network flow simulation device using the following command, which generates NetFlow data for testing purposes:

docker run -d --name=flow-device --restart=always --network=testnet --privileged networkstatic/nflow-generator -t 10.10.0.8 -p 9995

Step 4: Inspect the netflow logs to verify data collection and processing:

docker container logs knetflow -f

By following these steps, you will have successfully set up a comprehensive network monitoring solution using New Relic. Monitor both SNMP and network flow data effectively, ensuring optimal performance and insightful analytics for your network infrastructure.

Report Generation

The New Relic Reports engine provides support for generating reports in several ways.

Template Reports

Template reports provide a mechanism for building custom reports using templates. Templates are text-based, user-defined documents that can contain both content and logic. Templates are processed when a template report is run to produce text-based output. Special bits of logic called extensions are provided that make it easy to use New Relic data in template reports. By default, the output is rendered in a browser to produce PDF output, but it is just as easy to disable rendering and deliver the template output in a variety of ways.

Dashboard Reports

Dashboard reports use Nerdgraph to collect snapshot URLs from one or more user specified dashboard GUIDs. Snapshot URLs are downloaded as PDFs. When more than one dashboard is specified, the PDFs can optionally be concatenated into a single PDF.

Query Reports

Query reports provide a mechanism to export the results of running a NRQL query by simply specifying a query and one or more account IDs to run the query against. No additional configuration is required. By default, query results are exported to CSV but can also be exported as HTML or JSON.

Report Delivery

A variety of mechanisms are supported for delivering report output. These mechanisms are referred to as channels. The following types of channels are supported.

• File: Report output is saved to a file and copied to a destination directory on the local filesystem. Mostly meant for development and testing purposes.
• Email: Report output is included inline or as attachments to an email using a user defined email template and sent via SMTP.
• S3: Report output is saved to a file and uploaded to an S3 bucket.
• Slack: Report output is posted to a Slack channel via a Slack webhook.
• Webhook: Report output is posted to a custom Webhook.

Running Reports

There are several ways to run reports using the reporting engine.

• Packaged as a Docker image
• Packaged as an AWS Lambda function
• Using the command line interface (CLI)

You can find the documentation here : https://github.com/newrelic/nr-reports

Example: Exporting Infrastructure Data  into CSV

The following example is exporting infrastructure information such as average CPU percentage, average memory consumption, and average disk used percentage. The process will produce a csv file in a /shared directory.

• Clone New Relic Report Repository

git clone https://github.com/newrelic/nr-reports.git

• Create a configuration file in  include/manifest.json

"reports": [
    {
      "id": "monthly-report-infrastructure-csv",
      "name": "Monthy Report Infrastructure Application Export",
      "query": "FROM SystemSample SELECT average(cpuPercent), average(memoryUsedPercent), average(diskUsedPercent)  FACET CONCAT(yearOf(timestamp),'-', monthOf(timestamp, numeric), '-', dayOfMonthOf(timestamp) ),  hostname SINCE 30 days ago ",
      "accountIds": [412XXXX],
      "publishConfigs": [
        {
          "id": "email-report-to-team-lead",
          "name": "Email Monthy Report Infrastructure Application Export",
          "enabled": true,
          "channels": [
            {
              "id": "send-email",
              "name": "Email CSV report to leadership",
              "type": "email",
              "subject": "Monthy CSV Reports",
              "from": "noreply@numbers.local",
              "to": "sre@local.number"            
            }
          ]
        },
        {
          "id": "copy-file-to-share-folder",
          "name": "Copy file to shared folder",
        "enabled": true,
          "file": "file",
          "destDir": "../shared"
        }
      ]
    }
  ]

• Provide New Relic User Key

export NEWRELIC_API_KEY=NRAK-XXXXCWWVDELIESQ5HOXXXXXXXX  Running Report using CLI to send it via email  

• Running Report using CLI to export to file

2025-3-7,ip-172-55-0-18.us-west-1.compute.internal,96.60909271541009,48.125390290364535,46.09558587597476
2025-2-24,ip-172-55-0-230.us-west-1.compute.internal,80.56907379745788,72.22668904493572,63.02241926143477
2025-3-5,ip-172-55-1-30.us-west-1.compute.internal,80.00059415402947,70.45140724196332,44.44316987752953
2025-2-25,ip-172-55-1-30.us-west-1.compute.internal,79.24491489267055,69.46324664053066,51.986003841133524
2025-2-24,ip-172-55-1-30.us-west-1.compute.internal,79.11447436629201,69.6598443623585,50.00225214805742
2025-2-23,ip-172-55-1-30.us-west-1.compute.internal,78.96558749066773,69.69816959642057,47.56364219981973
2025-2-22,ip-172-55-1-30.us-west-1.compute.internal,77.95783378986545,69.55012400593432,45.60866208243937
2025-3-17,ip-172-55-0-162.us-west-1.compute.internal,77.95216780161854,65.42834469450302,56.06728147396647
2025-2-27,ip-172-55-1-30.us-west-1.compute.internal,77.88994464152246,67.71309150787259,37.95243397356807
2025-2-28,ip-172-55-1-30.us-west-1.compute.internal,77.29462638314907,67.79869230187556,39.30579816256979

1. Running Report using CLI to send it via email

sh nr-reports-cli/bin/nr-reports.sh -f include/manifest.json -u email-report-to-team-lead

Sample Output

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.

bundler is a gem that manages other Ruby gems. It makes sure your gems and gem versions are compatible, and that you have all necessary dependencies each gem requires.

The Gemfile and Gemfile.lock files inform Bundler about the gem requirements in your site. If your site doesn’t have these Gemfiles, you can omit bundle exec and just run jekyll serve.

When you run bundle exec jekyll serve, Bundler uses the gems and versions as specified in Gemfile.lock to ensure your Jekyll site builds with no compatibility or dependency conflicts.

For more information about how to use Bundler in your Jekyll project, this tutorial should provide answers to the most common questions and explain how to get up and running quickly.

If you’ve gotten pretty comfortable with writing in Markdown, then you may enjoy some more advanced tips about the types of things you can do with Markdown!

As with the last post about the editor, you’ll want to be actually editing this post as you read it so that you can see all the Markdown code we’re using.

Special formatting

As well as bold and italics, you can also use some other special formatting in Markdown when the need arises, for example:

• strike through
• ==highlight==
• *escaped characters*

Writing code blocks

There are two types of code elements which can be inserted in Markdown, the first is inline, and the other is block. Inline code is formatted by wrapping any word or words in back-ticks, like this. Larger snippets of code can be displayed across multiple lines using triple back ticks:

.my-link {
    text-decoration: underline;
}

If you want to get really fancy, you can even add syntax highlighting using Rouge.

Reference lists

The quick brown jumped over the lazy.

Another way to insert links in markdown is using reference lists. You might want to use this style of linking to cite reference material in a Wikipedia-style. All of the links are listed at the end of the document, so you can maintain full separation between content and its source or reference.

Full HTML

Perhaps the best part of Markdown is that you’re never limited to just Markdown. You can write HTML directly in the Markdown editor and it will just work as HTML usually does. No limits! Here’s a standard YouTube embed code as an example:

• To install the Jekyll site into the directory you’re currently in, run jekyll new . If the existing directory isn’t empty, you can pass the –force option with jekyll new . –force.
• jekyll new automatically initiates bundle install to install the dependencies required. (If you don’t want Bundler to install the gems, use jekyll new myblog --skip-bundle.)
• By default, the Jekyll site installed by jekyll new uses a gem-based theme called Minima. With gem-based themes, some of the directories and files are stored in the theme-gem, hidden from your immediate view.
• We recommend setting up Jekyll with a gem-based theme but if you want to start with a blank slate, use jekyll new myblog --blank
• To learn about other parameters you can include with jekyll new, type jekyll new --help.

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.