Monitoring Your ISP Using InfluxDB Cloud and Raspberry Pi
0 likes247 views
The document discusses a project focused on monitoring internet speed using various technologies including Raspberry Pi, InfluxDB, and Grafana. It outlines the pros and cons of different solutions for data collection, visualization, and communication, while suggesting a shift to InfluxDB2 for improved functionalities. Additionally, it mentions the implementation details for automated speed tests and data handling procedures.
1 of 47
Download to read offline
![[[outputs.influxdb_v2]]
urls = [ "${SPEEDTEST_SERVERURL}" ]
token = "${SPEEDTEST_TOKEN}"
organization = "${SPEEDTEST_ORGANIZATION}"
bucket = "${SPEEDTEST_BUCKET}"
[[processors.converter]]
[processors.converter.fields]
string = [
"server_id",
]
integer = [
"server_port",
]
float = [
"download_bandwidth",
"download_bytes",
"download_elapsed",
"upload_bandwidth",
"upload_bytes",
"upload_elapsed",
"packetLoss",
"ping_latency",
"ping_jitter",
]
[[inputs.exec]]
interval = "15m"
commands = [
"/usr/bin/speedtest --accept-license --accept-gdpr -f
json",
]
name_override="${SPEEDTEST_MEASUREMENT}"
timeout = "60s"
data_format = "json"
json_time_format = "2006-01-02T15:04:05Z"
json_time_key = "timestamp"
tag_keys = [
"interface_externalIp",
"interface_internalIp",
"isp",
"server_host"
]
json_string_fields = [
"server_location",
"server_name",
"server_testcountry",
"server_ip",
"result_id",
"result_url",
]](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-24-320.jpg)
![from(bucket: mybucket)
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) =>
r["_measurement"] == mymeasurement and (
r["_field"] == "download_bandwidth" or
r["_field"] == "upload_bandwidth" or
r["_field"] == "ping_latency"
)
)
|> keep(columns: ["_time", "_field", "_value"])
|> aggregateWindow(every: v.windowPeriod, fn: valmean, createEmpty: false)
|> map(fn: (r) => ({
r with _value: if (r._field == "download_bandwidth" or r._field == "upload_bandwidth") then
r._value * 8.0 else r._value
})
)](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-25-320.jpg)
![from(bucket: mybucket)
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) =>
r["_measurement"] == mymeasurement and (
r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "ping_latency" or r["_field"] ==
"server_name" or r["_field"] == "packetLoss" or r["_field"] == "server_location")
)
|> pivot(rowKey:["_time"], columnKey:["_field"], valueColumn:"_value")
|> group(columns: ["server_host"])
|> keep(columns: ["download_bandwidth", "upload_bandwidth", "ping_latency", "packetLoss", "server_location", "server_name", "serve
r_host"])
|> reduce(identity: {
server_name: "", server_location: "", valcount: 0.0, download_bandwidth: 0.0, upload_bandwidth: 0.0, ping_latency: 0.0, packet
Loss: 0.0, },
fn: (r, accumulator) => ({
server_name: r.server_name,
server_location: r.server_location,
valcount: accumulator.valcount + 1.0,
download_bandwidth: (r.download_bandwidth + accumulator.download_bandwidth * accumulator.valcount) / (accumulator.valcount + 1
.0),
upload_bandwidth: (r.upload_bandwidth + accumulator.upload_bandwidth * accumulator.valcount) / (accumulator.valcount + 1.0),
ping_latency: (r.ping_latency + accumulator.ping_latency * accumulator.valcount) / (accumulator.valcount + 1.0),
packetLoss: (r.packetLoss + accumulator.packetLoss * accumulator.valcount) / (accumulator.valcount + 1.0),
})
)
|> map(fn: (r) => ({ r with download_bandwidth: r.download_bandwidth * 8.0, upload_bandwidth: r.upload_bandwidth * 8.0 }))
|> drop(columns: ["server_host"])](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-27-320.jpg)
![from(bucket: mybucket)
|> range(start: v.timeRangeStart, stop: v.timeRangeStop)
|> filter(fn: (r) =>
r["_measurement"] == mymeasurement and (
r["_field"] == "results_id" or
r["_field"] == "server_name" or
r["_field"] == "server_location"
)
)
|> keep(columns: ["_time", "_field", "_value"])
|> sort(columns: ["_time"], desc: true)](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-29-320.jpg)
![import "experimental"
import "date"
option task = {name: "DailyMinMax", cron: "0 2 * * *"}
today = () => (date.truncate(t: now(), unit: 1d))
yesterday = (boundary="start") => {
timeValue = if boundary == "end" then experimental.subDuration(d: 1ns, from: today()) else experimental.subDuration(d: 24h, from: today())
return timeValue
}
from(bucket: mybucket)
|> range(start: yesterday(), stop: yesterday(boundary: "end"))
|> timeShift(duration: 1h, columns: ["_start", "_stop", "_time"])
|> filter(fn: (r) => (r["_measurement"] == mymeasurement and (r["_field"] ==
"download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "pingLatency")))
|> keep(columns: ["_time", "_field", "_value"])
|> reduce(identity: { valcount: 0.0, valmin: 0.0, valmax: 0.0, valmean: 0.0, }, fn: (r, accumulator) =>
({
valcount: accumulator.valcount + 1.0,
valmin: if accumulator.valcount == 0.0 then r._value else if r._value < accumulator.valmin then r._value else accumulator.valmin,
valmax: if accumulator.valcount == 0.0 then r._value else if r._value > accumulator.valmax then r._value else accumulator.valmax,
valmean: (r._value + accumulator.valmean * accumulator.valcount) / (accumulator.valcount + 1.0),
}))
|> map(fn: (r) => ({r with _time: yesterday(boundary: "end"), _measurement: "daily", data: r._field}))
|> to( bucket: <mybucket>, org: <myorganization>, tagColumns: ["data"], fieldFn: (r) =>
({ "valcount": r.valcount, "valmean": r.valmean, "valmin": r.valmin, "valmax": r.valmax, }))](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-31-320.jpg)
![ Visual feedback
Periodical & on-demand
Python + AstroPi(kind-of)
info: astro-pi.org
[...]
self.query = 'import "math"
from(bucket: "' + self.bucket + '")
|> range(start: -1d)
|> filter(fn: (r) =>
r["host"] == "%s" and
r["_measurement"] == "' + self.measurement + '" and (
r["_field"] == "download_bandwidth" or
r["_field"] == "upload_bandwidth" or
r["_field"] == "ping_latency"
)
)
|> keep(columns: ["_time", "_field", "_value"])
|> sort(columns: ["_time"], desc: false)
|> last()
|> map(fn: (r) => ({
r with _value: if (r._field == "download_bandwidth" or r._field ==
"upload_bandwidth") then math.round(x: (r._value * 8.0 / 10000.0)) /
100.0 else r._value
})
)
|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn:
"_value")'
db_client = InfluxDBClient(url=self.url, token=self.token,
org=self.org)
db_data = db_client.query_api().query_stream(query=(self.query_string
% hostsname), org=self.org)
[...]](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-34-320.jpg)
![ Visual feedback
Periodical & on-demand
Python + AstroPi(kind-of)
info: astro-pi.org
[...]
self.query = 'import "math"
from(bucket: "' + self.bucket + '")
|> range(start: -1d)
|> filter(fn: (r) =>
r["host"] == "%s" and
r["_measurement"] == "' + self.measurement + '" and (
r["_field"] == "download_bandwidth" or
r["_field"] == "upload_bandwidth" or
r["_field"] == "ping_latency"
)
)
|> keep(columns: ["_time", "_field", "_value"])
|> sort(columns: ["_time"], desc: false)
|> last()
|> map(fn: (r) => ({
r with _value: if (r._field == "download_bandwidth" or r._field ==
"upload_bandwidth") then math.round(x: (r._value * 8.0 / 10000.0)) /
100.0 else r._value
})
)
|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn:
"_value")'
db_client = InfluxDBClient(url=self.url, token=self.token,
org=self.org)
db_data = db_client.query_api().query_stream(query=(self.query_string
% hostsname), org=self.org)
[...]](https://image.slidesharecdn.com/20210407comparettimdispmonitoring-210407191706/85/Monitoring-Your-ISP-Using-InfluxDB-Cloud-and-Raspberry-Pi-35-320.jpg)
Ad
Recommended
Time Series Meetup: Virtual Edition | July 2020
Time Series Meetup: Virtual Edition | July 2020InfluxData This document summarizes an online meetup about anomaly detection using Median Absolute Deviation (MAD) in Flux. It includes an agenda with introductions, a talk on MAD, and time for Q&A. The talk explains how MAD works through numerical examples and uses common Flux functions like group(), drop(), median(), map(), and join(). It also provides instructions for writing custom Flux functions and packages and contributing them to the Flux codebase through testing and compilation.
Obtaining the Perfect Smoke By Monitoring Your BBQ with InfluxDB and Telegraf
Obtaining the Perfect Smoke By Monitoring Your BBQ with InfluxDB and TelegrafInfluxData The document details a virtual meetup event focused on monitoring BBQs using InfluxDB and Telegraf. It covers methods utilizing Python and MQTT, demonstrating setup and integration for real-time temperature monitoring. Future enhancements and additional features like alert systems and forecasting are also discussed.
Performance Profiling in Rust
Performance Profiling in RustInfluxData The document discusses various techniques for profiling CPU and memory performance in Rust programs, including:
- Using the flamegraph tool to profile CPU usage by sampling a running process and generating flame graphs.
- Integrating pprof profiling into Rust programs to expose profiles over HTTP similar to how it works in Go.
- Profiling heap usage by integrating jemalloc profiling and generating heap profiles on program exit.
- Some challenges with profiling asynchronous Rust programs due to the lack of backtraces.
The key takeaways are that there are crates like pprof-rs and techniques like jemalloc integration that allow collecting CPU and memory profiles from Rust programs, but profiling asynchronous programs
Meet the Experts: Visualize Your Time-Stamped Data Using the React-Based Gira...
Meet the Experts: Visualize Your Time-Stamped Data Using the React-Based Gira...InfluxData This document discusses Giraffe, a React-based library for visualizing time-series data from InfluxData. It provides examples of using Giraffe to visualize data exported from Flux queries in InfluxData by converting the data to layers in Giraffe configurations. The document also contains code examples for connecting to InfluxData and executing Flux queries to export data to visualize in Giraffe.
Using Grafana with InfluxDB 2.0 and Flux Lang by Jacob Lisi
Using Grafana with InfluxDB 2.0 and Flux Lang by Jacob LisiInfluxData The document discusses the new Flux support in Grafana, highlighting its powerful capabilities and the availability of a datasource plugin. It emphasizes the design goals of Flux, including decoupling language from the execution engine and database from query computation, along with the features for user-defined functions and query planning. Additionally, it provides guidance on setting up Flux in Grafana and mentions future enhancements such as alerting and UI improvements.
Presto in Treasure Data
Presto in Treasure DataMitsunori Komatsu Presto is a fast, distributed SQL query engine that allows for ad-hoc queries against data sources like Cassandra, Hive, Kafka and others. It uses a pluggable connector architecture that allows it to connect to different data sources. Presto's query execution is distributed across worker nodes and queries are compiled to Java bytecode for efficient execution. Some limitations of Presto include its inability to handle large joins and lack of fault tolerance.
Ordered Record Collection
Ordered Record CollectionHadoop User Group The document discusses different approaches to sorting in MapReduce frameworks over time. It describes Hadoop versions between 0.10-0.22, where sorting was handled by buffering records in memory, spilling to disk when thresholds were exceeded, and merging the spilled files. Later versions improved by distributing the sorting work across maps and making the memory footprint more predictable.
Flux and InfluxDB 2.0 by Paul Dix
Flux and InfluxDB 2.0 by Paul DixInfluxData The document provides a comprehensive overview of Flux and InfluxDB 2.0, detailing its functional data scripting language, features like multi-tenancy, and migration paths. It discusses structures such as buckets, tasks, and roles, as well as code examples for data retrieval, filtering, and processing tasks. Notably, it covers various functional elements such as loops, error handling, and packages for building and managing data scripts.
InfluxDB IOx Tech Talks: Query Processing in InfluxDB IOx
InfluxDB IOx Tech Talks: Query Processing in InfluxDB IOxInfluxData The document discusses query processing in InfluxDB IOX, detailing its data model, storage organization, and execution plans. It covers the architecture of chunked data storage, optimization features, and the unified engine design utilizing DataFusion and Arrow for query execution. Additionally, it explains front-end operations and metadata queries essential for performance and data lifecycle management.
User Defined Aggregation in Apache Spark: A Love Story
User Defined Aggregation in Apache Spark: A Love StoryDatabricks This document summarizes a user's journey developing a custom aggregation function for Apache Spark using a T-Digest sketch. The user initially implemented it as a User Defined Aggregate Function (UDAF) but ran into performance issues due to excessive serialization/deserialization. They then worked to resolve it by implementing the function as a custom Aggregator using Spark 3.0's new aggregation APIs, which avoided unnecessary serialization and provided a 70x performance improvement. The story highlights the importance of understanding how custom functions interact with Spark's execution model and optimization techniques like avoiding excessive serialization.
Upgrading To The New Map Reduce API
Upgrading To The New Map Reduce APITom Croucher The document summarizes the key changes between the old MapReduce API and the new MapReduce API in Hadoop. Some of the main changes include:
- Renaming all "mapred" packages to "mapreduce"
- Methods can now throw InterruptedException in addition to IOException
- Using Configuration instead of JobConf
- Changes to Mapper, Reducer, and RecordReader interfaces and classes
- Submitting jobs uses the Job class instead of JobConf and JobClient classes
- InputFormats and OutputFormats see changes like new methods and removed classes
MariaDB and Clickhouse Percona Live 2019 talk
MariaDB and Clickhouse Percona Live 2019 talkAlexander Rubin The document compares MariaDB ColumnStore and ClickHouse as solutions to slow query performance in a MySQL environment, specifically in handling medical insurance records. It presents real-world examples highlighting the speed and storage efficiency improvements offered by column-oriented databases, showing significant performance gains over MySQL. Additionally, it discusses export and integration processes while outlining the advantages and disadvantages of both database systems.
Wprowadzenie do technologi Big Data i Apache Hadoop
Wprowadzenie do technologi Big Data i Apache HadoopSages The document introduces concepts related to Big Data technology including volume, variety, and velocity of data. It discusses Hadoop architecture including HDFS, MapReduce, YARN, and the Hadoop ecosystem. Examples are provided of common Big Data problems and how they can be solved using Hadoop frameworks like Pig, Hive, and Ambari.
Shrug2017 arcpy data_and_you
Shrug2017 arcpy data_and_youSHRUG GIS This document provides an agenda and overview for a presentation on bridging the ESRI platform with Python and other databases. It discusses connection files in ESRI, using ArcPy cursors to read, insert and update data, connecting to databases like Oracle and SQL Server with Python libraries, and using SQLite as an alternative spatial database. It provides code examples for inserting CSV data into a SQLite database table and then inserting that data into a feature class. The final example shows updating data in a SQL Server database table.
Wprowadzenie do technologii Big Data / Intro to Big Data Ecosystem
Wprowadzenie do technologii Big Data / Intro to Big Data EcosystemSages The document provides an introduction to big data technologies, covering key components such as MapReduce, Pig, and Hive, along with various data storage options like NoSQL databases. It discusses practical applications, including optimizing waste collection based on street data and fraud detection through transactional data analysis. Additionally, it illustrates the architecture and commands of Hadoop, emphasizing the importance of batch processing, scalability, and various data formats.
Engineering Fast Indexes for Big-Data Applications: Spark Summit East talk by...
Engineering Fast Indexes for Big-Data Applications: Spark Summit East talk by...Spark Summit The document discusses the implementation and performance optimizations of engineering fast indexes using a hybrid model that leverages containers like sorted arrays, bitsets, and runs. It details the methods for performing operations such as union, intersection, and cardinality tracking while emphasizing the efficiency of SIMD instructions in parallelizing computations. The document also touches on how programming languages like Java manage these operations through intrinsic support for hardware capabilities like popcount and vectorization.
InfluxDB IOx Tech Talks: Intro to the InfluxDB IOx Read Buffer - A Read-Optim...
InfluxDB IOx Tech Talks: Intro to the InfluxDB IOx Read Buffer - A Read-Optim...InfluxData The document discusses updates and progress on InfluxDB IOx, a new columnar time series database, highlighting developments like a read buffer, management API, and future capabilities such as parquet persistence and replication. It emphasizes the importance of columnar data layout for analytical workloads and details various data organization and compression techniques in IOx. The presentation outlines the architecture, data models, and future enhancements aimed at improving performance and data handling for time-series use cases.
ClickHouse Query Performance Tips and Tricks, by Robert Hodges, Altinity CEO
ClickHouse Query Performance Tips and Tricks, by Robert Hodges, Altinity CEOAltinity Ltd 1. ClickHouse uses a MergeTree storage engine that stores data in compressed columnar format and partitions data into parts for efficient querying.
2. Query performance can be optimized by increasing threads, reducing data reads through filtering, restructuring queries, and changing the data layout such as partitioning strategy and primary key ordering.
3. Significant performance gains are possible by optimizing the data layout, such as keeping an optimal number of partitions, using encodings to reduce data size, and skip indexes to avoid unnecessary I/O. Proper indexes and encodings can greatly accelerate queries.
ClickHouse Features for Advanced Users, by Aleksei Milovidov
ClickHouse Features for Advanced Users, by Aleksei MilovidovAltinity Ltd This document summarizes key features for advanced users of ClickHouse, an open-source column-oriented database management system. It describes sample keys that can be defined in MergeTree tables to generate instant reports on large customer data. It also summarizes intermediate aggregation states, consistency modes, and tools for processing data without a server like clickhouse-local.
Taming the Tiger: Tips and Tricks for Using Telegraf
Taming the Tiger: Tips and Tricks for Using TelegrafInfluxData The document provides a comprehensive overview of setting up and configuring Telegraf, a lightweight metrics collection agent optimized for writing to InfluxDB. It includes instructions for installations, creating configuration files, and using plugins to filter and process data. Specific examples are given for various integrations and the use of the Starlark scripting for data manipulation.
ClickHouse tips and tricks. Webinar slides. By Robert Hodges, Altinity CEO
ClickHouse tips and tricks. Webinar slides. By Robert Hodges, Altinity CEOAltinity Ltd The document introduces ClickHouse, a high-performance open-source database management system, emphasizing its efficient data handling through SQL, column storage, and parallel execution. It discusses various features such as logging, data compression, encodings, materialized views, and the use of dictionaries to optimize data retrieval. Additionally, it addresses management techniques like TTL for data retention and replication strategies using Zookeeper for distributed setups.
Webinar: Secrets of ClickHouse Query Performance, by Robert Hodges
Webinar: Secrets of ClickHouse Query Performance, by Robert HodgesAltinity Ltd The document provides an overview of ClickHouse, a columnar database management system, with a focus on optimizing its Mergetree storage engine for improved performance. Key goals include understanding data layout, query optimization without altering data, and performance monitoring, while the document highlights the significance of partitioning and indexing strategies for query efficiency. It emphasizes the importance of using ClickHouse's query logs and system tables for monitoring performance and offers various techniques for data restructuring and encoding to enhance overall execution speed.
Webinar slides: Adding Fast Analytics to MySQL Applications with Clickhouse
Webinar slides: Adding Fast Analytics to MySQL Applications with ClickhouseAltinity Ltd This document discusses adding fast analytics to MySQL applications with ClickHouse. It introduces ClickHouse and MySQL, noting that ClickHouse is optimized for analytics while MySQL is optimized for transactions. It then describes several options for using ClickHouse to accelerate analytics on MySQL data, including fully migrating tables to ClickHouse, keeping dimensions in MySQL and moving analytics data to ClickHouse, and accessing MySQL tables from ClickHouse using various methods like the MySQL database engine and table function.
ClickHouse and the Magic of Materialized Views, By Robert Hodges and Altinity...
ClickHouse and the Magic of Materialized Views, By Robert Hodges and Altinity...Altinity Ltd The document discusses the capabilities and advantages of materialized views in ClickHouse, showcasing their effectiveness in speeding up queries and efficiently handling large datasets. It provides examples of how materialized views can improve performance for various aggregate functions and last point queries, demonstrating significant speed improvements compared to traditional SQL queries. The document also touches on best practices for managing schema migrations and operational issues related to materialized views.
Codepot - Pig i Hive: szybkie wprowadzenie / Pig and Hive crash course
Codepot - Pig i Hive: szybkie wprowadzenie / Pig and Hive crash courseSages The document provides an introduction to data processing using Pig and Hive, focusing on MapReduce architecture and examples of data manipulation tasks. It includes details about using Hadoop ecosystem components, Pig Latin basics, and sample use cases involving data analytics projects like fraud detection and web crawling. The content elaborates on various programming constructs for data processing and optimization techniques.
Optimizing the Grafana Platform for Flux
Optimizing the Grafana Platform for FluxInfluxData The document provides an overview of using Flux within Grafana, highlighting that Flux is a powerful query language with a new datasource plugin available for Grafana. It discusses current limitations, such as the lack of an automated way to migrate dashboards from Influx queries to Flux, while presenting various examples of Flux queries and user-defined functions. Additionally, it outlines steps to get started with Flux and Grafana, including installation and configuration instructions.
Barbara Nelson [InfluxData] | How Can I Put That Dashboard in My App? | Influ...
Barbara Nelson [InfluxData] | How Can I Put That Dashboard in My App? | Influ...InfluxData The document outlines a process for integrating BART API data into a dashboard application using InfluxData's tools, focusing on obtaining, processing, and visualizing time series data. It describes steps including fetching data from BART API, using Telegraf for data processing, and visualizing the data with the Giraffe library. Additionally, it includes example queries and code snippets for connecting to InfluxDB and displaying wait times for trains.
Flux and InfluxDB 2.0
Flux and InfluxDB 2.0InfluxData InfluxDB 2.0 introduces a unified platform integrating Telegraf, Chronograf, and Kapacitor, with a focus on a clean migration path and compatibility. The new Flux scripting language enables functional data queries and manipulation, allowing users to filter, transform, and visualize time series data effectively. The document provides numerous examples of Flux queries highlighting various functionality, including data filtering and windowing for analytics.
Optimizing InfluxDB Performance in the Real World by Dean Sheehan, Senior Dir...
Optimizing InfluxDB Performance in the Real World by Dean Sheehan, Senior Dir...InfluxData The document discusses optimizing InfluxDB with a focus on data modeling, data ingestion, and querying practices. It outlines schema design goals, best practices for tagging and measurement creation, and provides insights on managing cardinality and ingestion methods using tools like Telegraf. Lastly, it covers query performance optimization strategies, such as using aggregate functions and managing configuration settings for improved performance.
9:40 am InfluxDB 2.0 and Flux – The Road Ahead Paul Dix, Founder and CTO | ...
9:40 am InfluxDB 2.0 and Flux – The Road Ahead Paul Dix, Founder and CTO | ...InfluxData The document discusses the evolution of InfluxDB from versions 0.0.1 to 2.0. Key points include the introduction of the line protocol in version 0.9.0, optimizations for performance and queries in later versions, and the introduction of Flux as a query language and for building tasks and packages. Version 2.0 unifies the database, tasks, and UI capabilities into a single platform with a consistent API across languages. It also introduces user packages for sharing Flux code and tasks.
More Related Content
What's hot (20)
InfluxDB IOx Tech Talks: Query Processing in InfluxDB IOx
InfluxDB IOx Tech Talks: Query Processing in InfluxDB IOxInfluxData The document discusses query processing in InfluxDB IOX, detailing its data model, storage organization, and execution plans. It covers the architecture of chunked data storage, optimization features, and the unified engine design utilizing DataFusion and Arrow for query execution. Additionally, it explains front-end operations and metadata queries essential for performance and data lifecycle management.
User Defined Aggregation in Apache Spark: A Love Story
User Defined Aggregation in Apache Spark: A Love StoryDatabricks This document summarizes a user's journey developing a custom aggregation function for Apache Spark using a T-Digest sketch. The user initially implemented it as a User Defined Aggregate Function (UDAF) but ran into performance issues due to excessive serialization/deserialization. They then worked to resolve it by implementing the function as a custom Aggregator using Spark 3.0's new aggregation APIs, which avoided unnecessary serialization and provided a 70x performance improvement. The story highlights the importance of understanding how custom functions interact with Spark's execution model and optimization techniques like avoiding excessive serialization.
Upgrading To The New Map Reduce API
Upgrading To The New Map Reduce APITom Croucher The document summarizes the key changes between the old MapReduce API and the new MapReduce API in Hadoop. Some of the main changes include:
- Renaming all "mapred" packages to "mapreduce"
- Methods can now throw InterruptedException in addition to IOException
- Using Configuration instead of JobConf
- Changes to Mapper, Reducer, and RecordReader interfaces and classes
- Submitting jobs uses the Job class instead of JobConf and JobClient classes
- InputFormats and OutputFormats see changes like new methods and removed classes
MariaDB and Clickhouse Percona Live 2019 talk
MariaDB and Clickhouse Percona Live 2019 talkAlexander Rubin The document compares MariaDB ColumnStore and ClickHouse as solutions to slow query performance in a MySQL environment, specifically in handling medical insurance records. It presents real-world examples highlighting the speed and storage efficiency improvements offered by column-oriented databases, showing significant performance gains over MySQL. Additionally, it discusses export and integration processes while outlining the advantages and disadvantages of both database systems.
Wprowadzenie do technologi Big Data i Apache Hadoop
Wprowadzenie do technologi Big Data i Apache HadoopSages The document introduces concepts related to Big Data technology including volume, variety, and velocity of data. It discusses Hadoop architecture including HDFS, MapReduce, YARN, and the Hadoop ecosystem. Examples are provided of common Big Data problems and how they can be solved using Hadoop frameworks like Pig, Hive, and Ambari.
Shrug2017 arcpy data_and_you
Shrug2017 arcpy data_and_youSHRUG GIS This document provides an agenda and overview for a presentation on bridging the ESRI platform with Python and other databases. It discusses connection files in ESRI, using ArcPy cursors to read, insert and update data, connecting to databases like Oracle and SQL Server with Python libraries, and using SQLite as an alternative spatial database. It provides code examples for inserting CSV data into a SQLite database table and then inserting that data into a feature class. The final example shows updating data in a SQL Server database table.
Wprowadzenie do technologii Big Data / Intro to Big Data Ecosystem
Wprowadzenie do technologii Big Data / Intro to Big Data EcosystemSages The document provides an introduction to big data technologies, covering key components such as MapReduce, Pig, and Hive, along with various data storage options like NoSQL databases. It discusses practical applications, including optimizing waste collection based on street data and fraud detection through transactional data analysis. Additionally, it illustrates the architecture and commands of Hadoop, emphasizing the importance of batch processing, scalability, and various data formats.
Engineering Fast Indexes for Big-Data Applications: Spark Summit East talk by...
Engineering Fast Indexes for Big-Data Applications: Spark Summit East talk by...Spark Summit The document discusses the implementation and performance optimizations of engineering fast indexes using a hybrid model that leverages containers like sorted arrays, bitsets, and runs. It details the methods for performing operations such as union, intersection, and cardinality tracking while emphasizing the efficiency of SIMD instructions in parallelizing computations. The document also touches on how programming languages like Java manage these operations through intrinsic support for hardware capabilities like popcount and vectorization.
InfluxDB IOx Tech Talks: Intro to the InfluxDB IOx Read Buffer - A Read-Optim...
InfluxDB IOx Tech Talks: Intro to the InfluxDB IOx Read Buffer - A Read-Optim...InfluxData The document discusses updates and progress on InfluxDB IOx, a new columnar time series database, highlighting developments like a read buffer, management API, and future capabilities such as parquet persistence and replication. It emphasizes the importance of columnar data layout for analytical workloads and details various data organization and compression techniques in IOx. The presentation outlines the architecture, data models, and future enhancements aimed at improving performance and data handling for time-series use cases.
ClickHouse Query Performance Tips and Tricks, by Robert Hodges, Altinity CEO
ClickHouse Query Performance Tips and Tricks, by Robert Hodges, Altinity CEOAltinity Ltd 1. ClickHouse uses a MergeTree storage engine that stores data in compressed columnar format and partitions data into parts for efficient querying.
2. Query performance can be optimized by increasing threads, reducing data reads through filtering, restructuring queries, and changing the data layout such as partitioning strategy and primary key ordering.
3. Significant performance gains are possible by optimizing the data layout, such as keeping an optimal number of partitions, using encodings to reduce data size, and skip indexes to avoid unnecessary I/O. Proper indexes and encodings can greatly accelerate queries.
ClickHouse Features for Advanced Users, by Aleksei Milovidov
ClickHouse Features for Advanced Users, by Aleksei MilovidovAltinity Ltd This document summarizes key features for advanced users of ClickHouse, an open-source column-oriented database management system. It describes sample keys that can be defined in MergeTree tables to generate instant reports on large customer data. It also summarizes intermediate aggregation states, consistency modes, and tools for processing data without a server like clickhouse-local.
Taming the Tiger: Tips and Tricks for Using Telegraf
Taming the Tiger: Tips and Tricks for Using TelegrafInfluxData The document provides a comprehensive overview of setting up and configuring Telegraf, a lightweight metrics collection agent optimized for writing to InfluxDB. It includes instructions for installations, creating configuration files, and using plugins to filter and process data. Specific examples are given for various integrations and the use of the Starlark scripting for data manipulation.
ClickHouse tips and tricks. Webinar slides. By Robert Hodges, Altinity CEO
ClickHouse tips and tricks. Webinar slides. By Robert Hodges, Altinity CEOAltinity Ltd The document introduces ClickHouse, a high-performance open-source database management system, emphasizing its efficient data handling through SQL, column storage, and parallel execution. It discusses various features such as logging, data compression, encodings, materialized views, and the use of dictionaries to optimize data retrieval. Additionally, it addresses management techniques like TTL for data retention and replication strategies using Zookeeper for distributed setups.
Webinar: Secrets of ClickHouse Query Performance, by Robert Hodges
Webinar: Secrets of ClickHouse Query Performance, by Robert HodgesAltinity Ltd The document provides an overview of ClickHouse, a columnar database management system, with a focus on optimizing its Mergetree storage engine for improved performance. Key goals include understanding data layout, query optimization without altering data, and performance monitoring, while the document highlights the significance of partitioning and indexing strategies for query efficiency. It emphasizes the importance of using ClickHouse's query logs and system tables for monitoring performance and offers various techniques for data restructuring and encoding to enhance overall execution speed.
Webinar slides: Adding Fast Analytics to MySQL Applications with Clickhouse
Webinar slides: Adding Fast Analytics to MySQL Applications with ClickhouseAltinity Ltd This document discusses adding fast analytics to MySQL applications with ClickHouse. It introduces ClickHouse and MySQL, noting that ClickHouse is optimized for analytics while MySQL is optimized for transactions. It then describes several options for using ClickHouse to accelerate analytics on MySQL data, including fully migrating tables to ClickHouse, keeping dimensions in MySQL and moving analytics data to ClickHouse, and accessing MySQL tables from ClickHouse using various methods like the MySQL database engine and table function.
ClickHouse and the Magic of Materialized Views, By Robert Hodges and Altinity...
ClickHouse and the Magic of Materialized Views, By Robert Hodges and Altinity...Altinity Ltd The document discusses the capabilities and advantages of materialized views in ClickHouse, showcasing their effectiveness in speeding up queries and efficiently handling large datasets. It provides examples of how materialized views can improve performance for various aggregate functions and last point queries, demonstrating significant speed improvements compared to traditional SQL queries. The document also touches on best practices for managing schema migrations and operational issues related to materialized views.
Codepot - Pig i Hive: szybkie wprowadzenie / Pig and Hive crash course
Codepot - Pig i Hive: szybkie wprowadzenie / Pig and Hive crash courseSages The document provides an introduction to data processing using Pig and Hive, focusing on MapReduce architecture and examples of data manipulation tasks. It includes details about using Hadoop ecosystem components, Pig Latin basics, and sample use cases involving data analytics projects like fraud detection and web crawling. The content elaborates on various programming constructs for data processing and optimization techniques.
Optimizing the Grafana Platform for Flux
Optimizing the Grafana Platform for FluxInfluxData The document provides an overview of using Flux within Grafana, highlighting that Flux is a powerful query language with a new datasource plugin available for Grafana. It discusses current limitations, such as the lack of an automated way to migrate dashboards from Influx queries to Flux, while presenting various examples of Flux queries and user-defined functions. Additionally, it outlines steps to get started with Flux and Grafana, including installation and configuration instructions.
Barbara Nelson [InfluxData] | How Can I Put That Dashboard in My App? | Influ...
Barbara Nelson [InfluxData] | How Can I Put That Dashboard in My App? | Influ...InfluxData The document outlines a process for integrating BART API data into a dashboard application using InfluxData's tools, focusing on obtaining, processing, and visualizing time series data. It describes steps including fetching data from BART API, using Telegraf for data processing, and visualizing the data with the Giraffe library. Additionally, it includes example queries and code snippets for connecting to InfluxDB and displaying wait times for trains.
Flux and InfluxDB 2.0
Flux and InfluxDB 2.0InfluxData InfluxDB 2.0 introduces a unified platform integrating Telegraf, Chronograf, and Kapacitor, with a focus on a clean migration path and compatibility. The new Flux scripting language enables functional data queries and manipulation, allowing users to filter, transform, and visualize time series data effectively. The document provides numerous examples of Flux queries highlighting various functionality, including data filtering and windowing for analytics.
Similar to Monitoring Your ISP Using InfluxDB Cloud and Raspberry Pi (20)
Optimizing InfluxDB Performance in the Real World by Dean Sheehan, Senior Dir...
Optimizing InfluxDB Performance in the Real World by Dean Sheehan, Senior Dir...InfluxData The document discusses optimizing InfluxDB with a focus on data modeling, data ingestion, and querying practices. It outlines schema design goals, best practices for tagging and measurement creation, and provides insights on managing cardinality and ingestion methods using tools like Telegraf. Lastly, it covers query performance optimization strategies, such as using aggregate functions and managing configuration settings for improved performance.
9:40 am InfluxDB 2.0 and Flux – The Road Ahead Paul Dix, Founder and CTO | ...
9:40 am InfluxDB 2.0 and Flux – The Road Ahead Paul Dix, Founder and CTO | ...InfluxData The document discusses the evolution of InfluxDB from versions 0.0.1 to 2.0. Key points include the introduction of the line protocol in version 0.9.0, optimizations for performance and queries in later versions, and the introduction of Flux as a query language and for building tasks and packages. Version 2.0 unifies the database, tasks, and UI capabilities into a single platform with a consistent API across languages. It also introduces user packages for sharing Flux code and tasks.
Optimizing InfluxDB Performance in the Real World | Sam Dillard | InfluxData
Optimizing InfluxDB Performance in the Real World | Sam Dillard | InfluxDataInfluxData The document discusses optimizing InfluxDB performance through hardware, architecture, write methods, and schema design. Key points include effective resource utilization, use of Telegraf for data ingestion, and strategies for improving query performance and tuning parameters. It emphasizes the importance of schema design goals and efficient querying practices to enhance both write and read performance.
InfluxData Platform Future and Vision
InfluxData Platform Future and VisionInfluxData The document discusses the evolution of a query language called IFQL developed by InfluxData, which aims to unify various aspects of database querying and processing. It highlights the language's syntax, functionality, and goals for improving usability, flexibility, and feature velocity while decoupling storage from compute tasks. Additionally, it provides various examples illustrating the language's capabilities, emphasizing ease of use and readability.
Devoxx france 2015 influx db
Devoxx france 2015 influx dbNicolas Muller The document discusses InfluxDB, an open-source distributed time series database, highlighting its design goals, installation, and running processes. It covers the necessity of managing vast data from various events, the architecture's advantages, and query language capabilities. Additionally, it notes future enhancements and libraries related to InfluxDB, aiming to streamline data collection and analysis for IoT and other applications.
Devoxx france 2015 influxdb
Devoxx france 2015 influxdbNicolas Muller The document discusses InfluxDB, an open-source distributed time series database designed for ease of installation and management, with features such as HTTP interface, horizontal scalability, and on-the-fly computations. It highlights use cases, installation guides, security measures, query languages, and potential pitfalls. The document also outlines the design goals and upcoming features, including clustering and enhanced tagging for future releases.
Timely Year Two: Lessons Learned Building a Scalable Metrics Analytic System
Timely Year Two: Lessons Learned Building a Scalable Metrics Analytic SystemAccumulo Summit The document outlines the architecture and functioning of a scalable time series database (Timely) developed by Booz Allen Hamilton, which is built on Accumulo and designed for real-time metrics collection and analysis. It discusses key components such as collectd for metric gathering, NSQ for message routing, and Grafana for visualizations and alerts, while also addressing scaling strategies and challenges. Additionally, it shares lessons learned from deployment, monitoring, and data compaction issues encountered during implementation.
Timeseries - data visualization in Grafana
Timeseries - data visualization in GrafanaOCoderFest This document discusses using Grafana to visualize time series data stored in InfluxDB. It begins with an introduction to the speaker and agenda. It then discusses why Grafana is useful for quality assurance, anomaly detection, and monitoring analytics. It provides an overview of the monitoring process involving collecting metrics via StatsD and storing them in InfluxDB. Details are given about InfluxDB's purpose, structure, querying, downsampling and retention policies. Telegraf is described as an agent for collecting and processing metrics to send to InfluxDB. StatsD is explained as a protocol for incrementally reporting counters and gauges. Finally, Grafana's purpose, structure, data sources and dashboard creation are outlined, with examples shown in a demonstration.
Taming the Tiger: Tips and Tricks for Using Telegraf
Taming the Tiger: Tips and Tricks for Using TelegrafInfluxData The document provides an overview and detailed guide for setting up Telegraf, a metric collection agent, to work with InfluxDB Cloud. It covers configuration steps, enabling plugins, filtering data, and various exercises for practical implementation. The content is targeted at users participating in a training workshop, emphasizing both foundational knowledge and hands-on experience with Telegraf and InfluxDB integration.
Beautiful Monitoring With Grafana and InfluxDB
Beautiful Monitoring With Grafana and InfluxDBleesjensen The document outlines the features and installation process for InfluxDB and Grafana, focusing on historical metric storage, interactive exploration, and scalability. It discusses the installation commands, query language, and how to add and visualize metrics using Grafana. Additionally, it highlights future development goals and provides examples of query usage and dashboard configuration.
Tick
TickVincenzo Ferrari This document introduces the TICK stack, which is a collection of open source software tools for collecting, processing, storing, and visualizing metrics and events. It summarizes the main components: Telegraf collects metrics from servers and services and writes them to InfluxDB; InfluxDB is a time series database that stores metrics; Chronograf provides visualization of metrics stored in InfluxDB; and Kapacitor processes data from InfluxDB to perform tasks like anomaly detection and alerting. Examples are provided of how these tools can be used together in a workflow to monitor systems and applications.
InfluxDB 1.0 - Optimizing InfluxDB by Sam Dillard
InfluxDB 1.0 - Optimizing InfluxDB by Sam DillardInfluxData The document provides guidelines for optimizing InfluxDB performance, covering aspects like hardware architecture, schema design, and query optimization. Key topics include managing resource utilization, enhancing write and query performance through proper schema design, and tuning parameters for better efficiency. Additional insights on shard management and configurations help ensure robust database performance during peak loads.
StreamSight - Query-Driven Descriptive Analytics for IoT and Edge Computing
StreamSight - Query-Driven Descriptive Analytics for IoT and Edge ComputingDemetris Trihinas The document presents an approach for query-driven descriptive analytics in Internet of Things (IoT) and edge computing environments, highlighting the challenges of performing real-time analytics on massive data streams. It introduces the Streamsight framework designed to optimize query processing, utilizing edge computing capabilities to reduce latency and enhance response times. The framework incorporates techniques for query compilation, execution, and the reuse of intermediate results for efficient data analytics across geo-distributed topologies.
OPTIMIZING THE TICK STACK
OPTIMIZING THE TICK STACKInfluxData The document outlines a workshop agenda for new practitioners focusing on the Tick Stack, including sessions on installation, writing queries, architecting InfluxEnterprise, and optimizing data ingestion. It emphasizes best practices for data schema design within InfluxDB, particularly regarding the use of tags and fields, and provides examples related to IoT applications and air quality monitoring. Key considerations include the impact of schema on queries, the importance of optimizing data ingestion, and strategies for efficient query performance.
Flink Forward San Francisco 2018: - Jinkui Shi and Radu Tudoran "Flink real-t...
Flink Forward San Francisco 2018: - Jinkui Shi and Radu Tudoran "Flink real-t...Flink Forward The document presents Huawei Cloud's Cloud Stream Service using Flink, which offers real-time big data stream analysis with low latency and high throughput. It highlights cost savings compared to traditional offline environments and various job types supported by the service, including Flink SQL and Spark Streaming. Key features include easy use, serverless infrastructure, and integration capabilities for industrial IoT, banking, and e-commerce applications.
Advanced kapacitor
Advanced kapacitorInfluxData The document provides an agenda for a seasoned developers track workshop. The agenda includes sessions on InfluxDB query language (IFQL), writing Telegraf plugins, using InfluxDB for open tracing, advanced Kapacitor techniques, setting up InfluxData for IoT, and database orchestration. There will also be breakfast, lunch, breaks and pizza/beer.
Observability of InfluxDB IOx: Tracing, Metrics and System Tables
Observability of InfluxDB IOx: Tracing, Metrics and System TablesInfluxData The document discusses the observability features of InfluxDB IOx including system tables, metrics, logs, and distributed tracing. It provides examples of using the management API and SQL queries to view system tables and metrics. The talk outlines scenarios where observability helps such as detecting out of memory conditions, persistent compaction issues, and overlapping timestamps. It also explains how features are implemented using technologies like Protobuf, gRPC, Datafusion, OpenTelemetry, Tokio tracing, and Jaeger.
OPTIMIZING THE TICK STACK
OPTIMIZING THE TICK STACKInfluxData The document provides a comprehensive guide on optimizing the TICK stack, focusing on aspects such as hardware utilization, schema design, and query performance. Key points emphasize effective resource management, the importance of shard configuration, and best practices for writing data to InfluxDB using line protocol. Recommendations are made for tuning parameters to enhance both write and query performance while minimizing cardinality issues.
Russ Savage [Ngrok] | InfluxDB QuickStart | InfluxDays NA 2021
Russ Savage [Ngrok] | InfluxDB QuickStart | InfluxDays NA 2021InfluxData The document provides a quickstart guide for building an application that uses InfluxDB to present temperature readings, focusing on backend code and using Python and Flask. Key elements include requirements for public read/write APIs, data formatting using line protocol, and utilizing Flux for querying and aggregating data. It also covers client libraries, API token management, and performance optimization strategies for data operations.
Scott Anderson [InfluxData] | InfluxDB Tasks – Beyond Downsampling | InfluxDa...
Scott Anderson [InfluxData] | InfluxDB Tasks – Beyond Downsampling | InfluxDa...InfluxData This document outlines the use of InfluxDB tasks, emphasizing their functions for automating repeated operations and serving as a replacement for continuous queries. It provides examples of downsampling and monitoring scripts, including memory checks and alert notifications through Slack. Additionally, it touches on custom anomaly detection alerts and data ingestion methods using CSV.
Ad
More from InfluxData (20)
Announcing InfluxDB Clustered
Announcing InfluxDB ClusteredInfluxData The document introduces InfluxDB 3.0, a new columnar database designed for high performance and low total cost of ownership (TCO) in managing time series data. It highlights features like unlimited cardinality, real-time querying, and superior data compression, tailored for large enterprises and organizations seeking better control and security over their data. InfluxDB clustered combines these capabilities for customers deploying their own infrastructure, facilitating performance at scale and compliance with enterprise security standards.
Best Practices for Leveraging the Apache Arrow Ecosystem
Best Practices for Leveraging the Apache Arrow EcosystemInfluxData The document discusses how InfluxDB and Dremio utilize the Apache ecosystem, focusing on InfluxDB's new storage engine that incorporates Rust, Apache Arrow, and Parquet for efficient data storage and analytics. It highlights the benefits of columnar data storage, including improved performance and interoperability with machine learning tools. Additionally, it details Dremio's features, such as SQL interface support through Apache Calcite and optimization capabilities for data processing and management.
How Bevi Uses InfluxDB and Grafana to Improve Predictive Maintenance and Redu...
How Bevi Uses InfluxDB and Grafana to Improve Predictive Maintenance and Redu...InfluxData Bevi leverages InfluxDB and Grafana to enhance predictive maintenance and reduce its carbon footprint in the beverage industry, which faces significant environmental challenges. By utilizing a distributed beverage production system, Bevi not only cuts costs for customers but also promotes sustainability by minimizing single-use plastic bottles. The company successfully navigated technical challenges with InfluxDB 2.0 and has improved its performance through strategic event handling and batching.
Power Your Predictive Analytics with InfluxDB
Power Your Predictive Analytics with InfluxDBInfluxData The document discusses predictive analytics using time series databases, emphasizing their characteristics and applications across various industries such as IoT, manufacturing, and fintech. It highlights the usage of InfluxDB 3.0 alongside tools like Quix and Hugging Face for forecasting and anomaly detection. Additionally, it provides resources and community support for developers to get started with InfluxDB and predictive analytics.
How Teréga Replaces Legacy Data Historians with InfluxDB, AWS and IO-Base
How Teréga Replaces Legacy Data Historians with InfluxDB, AWS and IO-Base InfluxData Teréga is transitioning from legacy data historians to a cloud-based data management solution using InfluxDB in response to the growing need for digital tools in energy transition. The document details the challenges faced in data management, the reasons for choosing InfluxDB, and the security measures implemented to ensure data integrity. Upcoming enhancements include migrating to InfluxDB 3.0 for improved data retention and analytics capabilities.
Build an Edge-to-Cloud Solution with the MING Stack
Build an Edge-to-Cloud Solution with the MING StackInfluxData The document presents an overview of FlowForge, a tool built on Node-RED for developing event-driven applications, along with InfluxDB 3.0 for managing time series data. It outlines features, architecture, and examples focusing on health monitoring of household plants using data visualization and analysis. Additionally, it provides resources for further learning and community engagement.
Meet the Founders: An Open Discussion About Rewriting Using Rust
Meet the Founders: An Open Discussion About Rewriting Using RustInfluxData The document is an agenda for a discussion between the CTO and founder of Ockam, Mrinal Wadhwa, and the CTO and founder of InfluxData, Paul Dix, about rewriting products using the Rust programming language. It includes an introduction of the founders, an overview of the discussion topics like why they decided to rewrite in Rust and the challenges they faced, how they got their engineers comfortable with Rust, tips they learned in the process, benefits gained from moving to Rust, and how their communities responded to the switch.
Introducing InfluxDB Cloud Dedicated
Introducing InfluxDB Cloud DedicatedInfluxData The document introduces InfluxDB 3.0 and InfluxDB Cloud Dedicated, highlighting their optimizations for handling time series data at scale, with features like sub-second query responses and built-in data lifecycle management. It emphasizes the platform's adaptability for various workloads, security, and cost-effectiveness, alongside its use of modern technologies such as Apache Arrow and Parquet for efficient data processing. The target industries for adoption include gaming, fintech, and industrial IoT, showcasing its versatility across different applications.
Gain Better Observability with OpenTelemetry and InfluxDB
Gain Better Observability with OpenTelemetry and InfluxDB InfluxData The document provides an overview of leveraging OpenTelemetry with InfluxDB for improved observability, covering concepts such as logs, traces, and metrics. It details the capabilities of InfluxDB Cloud powered by the new IOx storage engine, emphasizing high performance, native SQL support, and integration with existing observability tools. Additionally, it offers guidelines for setting up an observability project using InfluxDB and OpenTelemetry.
How a Heat Treating Plant Ensures Tight Process Control and Exceptional Quali...
How a Heat Treating Plant Ensures Tight Process Control and Exceptional Quali...InfluxData The document discusses the operations and processes of a heat treating plant, emphasizing its significance in various industries and its commitment to quality control through digitization. It details the heat treating process, types of furnaces, and the importance of data collection for maintenance and cost management. Additionally, it highlights the need for a data-driven culture within the organization to optimize efficiency and product quality.
How Delft University's Engineering Students Make Their EV Formula-Style Race ...
How Delft University's Engineering Students Make Their EV Formula-Style Race ...InfluxData Marple is a frontend tool for engineers designed to enhance InfluxDB, tailored for data analysis needs, including advanced plotting and calculation features. It provides tips for effective usage, such as using scoped API tokens and structuring data with buckets and tags. Users can create a free account and start utilizing Marple for in-depth analysis of their datasets.
Introducing InfluxDB’s New Time Series Database Storage Engine
Introducing InfluxDB’s New Time Series Database Storage EngineInfluxData The document outlines a data measurement format, including optional tags and fields for recording metrics. It provides an example of a data entry for a server, including attributes like CPU load, temperature, and voltage. Additionally, it specifies the inclusion of a timestamp and hostname in the measurement.
Start Automating InfluxDB Deployments at the Edge with balena
Start Automating InfluxDB Deployments at the Edge with balena InfluxData The document provides an overview of utilizing Balena for automating InfluxDB deployments at the edge, particularly in the context of IoT solutions. It discusses components like the connector block for data handling, the Balena platform's capabilities, and specific use cases such as the Balenair indoor air quality device. Additionally, it outlines methods for data analysis and anomaly detection using cloud and edge computing technologies.
Understanding InfluxDB’s New Storage Engine
Understanding InfluxDB’s New Storage EngineInfluxData The document provides an overview of the new InfluxDB storage engine, highlighting its foundation on technologies like Rust, Apache Arrow, and Parquet and detailing key features such as support for unlimited cardinality, best-in-class performance, and broader ecosystem compatibility. It includes release details, SQL support, and interoperability plans, as well as a survey for user feedback. Additional resources and community engagement options are also outlined for users interested in getting started with the new engine.
Streamline and Scale Out Data Pipelines with Kubernetes, Telegraf, and InfluxDB
Streamline and Scale Out Data Pipelines with Kubernetes, Telegraf, and InfluxDBInfluxData The document discusses the integration of Kubernetes, Telegraf, and InfluxDB for streamlining and scaling data pipelines, emphasizing the features of RudderStack and its architecture. It highlights the necessity for fast, reliable tools and focuses on the usage of InfluxDB for storing and managing metrics efficiently. Key considerations for future metrics storage, migration, and ongoing evaluations of efficient options are also mentioned.
Ward Bowman [PTC] | ThingWorx Long-Term Data Storage with InfluxDB | InfluxDa...
Ward Bowman [PTC] | ThingWorx Long-Term Data Storage with InfluxDB | InfluxDa...InfluxData The document discusses the integration of InfluxDB with ThingWorx for long-term data storage, emphasizing its role as a scalable time-series database suited for industrial IoT applications. It highlights the advantages of using InfluxDB for high-volume data ingestion and real-time queries, along with the cloud-friendly architecture and data abstraction it offers. Additionally, it notes the partnership between PTC and InfluxData, promoting InfluxDB as the recommended storage option for ThingWorx customers.
Scott Anderson [InfluxData] | New & Upcoming Flux Features | InfluxDays 2022
Scott Anderson [InfluxData] | New & Upcoming Flux Features | InfluxDays 2022InfluxData The document outlines two upcoming features in Flux programming: polymorphic labels and dynamic types, which are designed to enhance data workflows by allowing more flexible functions and transformations. Polymorphic labels enable customizable column parameters, while dynamic types allow for working with external data sources that have unknown types at runtime. The document is presented by Scott Anderson, a technical writer for InfluxData, and includes examples and a recap of resources for further information.
Steinkamp, Clifford [InfluxData] | Closing Thoughts | InfluxDays 2022
Steinkamp, Clifford [InfluxData] | Closing Thoughts | InfluxDays 2022InfluxData This document outlines the schedule for Day 2 of InfluxDays 2022, an event hosted by InfluxData. The schedule includes sessions on building developer experience, how developers like to work, an overview of the InfluxDB developer console and API, demos of client libraries and the InfluxDB v2 API, tips for getting involved in the InfluxDB community and university, use cases for networking monitoring, crypto/fintech, monitoring/observability, and IIoT, and closing thoughts. Recordings of all sessions will be made available to registered attendees by November 7th. Upcoming events include advanced Flux training in London and resources through the community forums, Slack channel, and online university.
Steinkamp, Clifford [InfluxData] | Welcome to InfluxDays 2022 - Day 2 | Influ...
Steinkamp, Clifford [InfluxData] | Welcome to InfluxDays 2022 - Day 2 | Influ...InfluxData This document contains the agenda for Day 2 of InfluxDays 2022, which includes:
- Welcome and introductory remarks from Zoe Steinkamp and Jay Clifford of InfluxData.
- Fireside chats and presentations on building great developer experiences, how developers like to work, and use cases for InfluxDB from companies like Tesla, InfluxData, and others.
- Sessions on the InfluxDB developer console, APIs, client libraries, getting involved in the community, accelerating time to awesome with InfluxDB University, and tips for analyzing IoT data with InfluxDB.
- Closing thoughts from Zoe Steinkamp and Jay Clifford, as well as
Steinkamp, Clifford [InfluxData] | Closing Thoughts Day 1 | InfluxDays 2022
Steinkamp, Clifford [InfluxData] | Closing Thoughts Day 1 | InfluxDays 2022InfluxData The document summarizes the agenda and sessions for Day 1 of InfluxDays 2022. It includes sessions on InfluxDB data collection, scripting languages like Flux, the InfluxDB time series engine, tasks, storage, and a closing discussion. The agenda involves talks from InfluxData employees on building applications with real-time data, navigating the developer experience, solving problems, the InfluxDB platform, community, education, use cases in crypto/fintech and IIoT, and tips/tricks for analysis.
Ad
Recently uploaded (20)
10 Key Challenges for AI within the EU Data Protection Framework.pdf
10 Key Challenges for AI within the EU Data Protection Framework.pdfPriyanka Aash 10 Key Challenges for AI within the EU Data Protection Framework
Techniques for Automatic Device Identification and Network Assignment.pdf
Techniques for Automatic Device Identification and Network Assignment.pdfPriyanka Aash Techniques for Automatic Device Identification and Network Assignment
Security Tips for Enterprise Azure Solutions
Security Tips for Enterprise Azure SolutionsMichele Leroux Bustamante Delivering solutions to Azure may involve a variety of architecture patterns involving your applications, APIs data and associated Azure resources that comprise the solution. This session will use reference architectures to illustrate the security considerations to protect your Azure resources and data, how to achieve Zero Trust, and why it matters. Topics covered will include specific security recommendations for types Azure resources and related network security practices. The goal is to give you a breadth of understanding as to typical security requirements to meet compliance and security controls in an enterprise solution.
CapCut Pro Crack For PC Latest Version {Fully Unlocked} 2025
CapCut Pro Crack For PC Latest Version {Fully Unlocked} 2025pcprocore 👉𝗡𝗼𝘁𝗲:𝗖𝗼𝗽𝘆 𝗹𝗶𝗻𝗸 & 𝗽𝗮𝘀𝘁𝗲 𝗶𝗻𝘁𝗼 𝗚𝗼𝗼𝗴𝗹𝗲 𝗻𝗲𝘄 𝘁𝗮𝗯> https://pcprocore.com/ 👈◀
CapCut Pro Crack is a powerful tool that has taken the digital world by storm, offering users a fully unlocked experience that unleashes their creativity. With its user-friendly interface and advanced features, it’s no wonder why aspiring videographers are turning to this software for their projects.
2025_06_18 - OpenMetadata Community Meeting.pdf
2025_06_18 - OpenMetadata Community Meeting.pdfOpenMetadata The community meetup was held Wednesday June 18, 2025 @ 9:00 AM PST.
Catch the next OpenMetadata Community Meetup @ https://www.meetup.com/openmetadata-meetup-group/
In this month's OpenMetadata Community Meetup, "Enforcing Quality & SLAs with OpenMetadata Data Contracts," we covered data contracts, why they matter, and how to implement them in OpenMetadata to increase the quality of your data assets!
Agenda Highlights:
👋 Introducing Data Contracts: An agreement between data producers and consumers
📝 Data Contracts key components: Understanding a contract and its purpose
🧑🎨 Writing your first contract: How to create your own contracts in OpenMetadata
🦾 An OpenMetadata MCP Server update!
➕ And More!
War_And_Cyber_3_Years_Of_Struggle_And_Lessons_For_Global_Security.pdf
War_And_Cyber_3_Years_Of_Struggle_And_Lessons_For_Global_Security.pdfbiswajitbanerjee38 Russia is one of the most aggressive nations when it comes to state coordinated cyberattacks — and Ukraine has been at the center of their crosshairs for 3 years. This report, provided the State Service of Special Communications and Information Protection of Ukraine contains an incredible amount of cybersecurity insights, showcasing the coordinated aggressive cyberwarfare campaigns of Russia against Ukraine.
It brings to the forefront that understanding your adversary, especially an aggressive nation state, is important for cyber defense. Knowing their motivations, capabilities, and tactics becomes an advantage when allocating resources for maximum impact.
Intelligence shows Russia is on a cyber rampage, leveraging FSB, SVR, and GRU resources to professionally target Ukraine’s critical infrastructures, military, and international diplomacy support efforts.
The number of total incidents against Ukraine, originating from Russia, has steadily increased from 1350 in 2021 to 4315 in 2024, but the number of actual critical incidents has been managed down from a high of 1048 in 2022 to a mere 59 in 2024 — showcasing how the rapid detection and response to cyberattacks has been impacted by Ukraine’s improved cyber resilience.
Even against a much larger adversary, Ukraine is showcasing outstanding cybersecurity, enabled by strong strategies and sound tactics. There are lessons to learn for any enterprise that could potentially be targeted by aggressive nation states.
Definitely worth the read!
From Manual to Auto Searching- FME in the Driver's Seat
From Manual to Auto Searching- FME in the Driver's SeatSafe Software Finding a specific car online can be a time-consuming task, especially when checking multiple dealer websites. A few years ago, I faced this exact problem while searching for a particular vehicle in New Zealand. The local classified platform, Trade Me (similar to eBay), wasn’t yielding any results, so I expanded my search to second-hand dealer sites—only to realise that periodically checking each one was going to be tedious. That’s when I noticed something interesting: many of these websites used the same platform to manage their inventories. Recognising this, I reverse-engineered the platform’s structure and built an FME workspace that automated the search process for me. By integrating API calls and setting up periodic checks, I received real-time email alerts when matching cars were listed. In this presentation, I’ll walk through how I used FME to save hours of manual searching by creating a custom car-finding automation system. While FME can’t buy a car for you—yet—it can certainly help you find the one you’re after!
Lessons Learned from Developing Secure AI Workflows.pdf
Lessons Learned from Developing Secure AI Workflows.pdfPriyanka Aash Lessons Learned from Developing Secure AI Workflows
"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...
"How to survive Black Friday: preparing e-commerce for a peak season", Yurii ...Fwdays We will explore how e-commerce projects prepare for the busiest time of the year, which key aspects to focus on, and what to expect. We’ll share our experience in setting up auto-scaling, load balancing, and discuss the loads that Silpo handles, as well as the solutions that help us navigate this season without failures.
PyCon SG 25 - Firecracker Made Easy with Python.pdf
PyCon SG 25 - Firecracker Made Easy with Python.pdfMuhammad Yuga Nugraha Explore the ease of managing Firecracker microVM with the firecracker-python. In this session, I will introduce the basics of Firecracker microVM and demonstrate how this custom SDK facilitates microVM operations easily. We will delve into the design and development process behind the SDK, providing a behind-the-scenes look at its creation and features. While traditional Firecracker SDKs were primarily available in Go, this module brings a simplicity of Python to the table.
"Database isolation: how we deal with hundreds of direct connections to the d...
"Database isolation: how we deal with hundreds of direct connections to the d...Fwdays What can go wrong if you allow each service to access the database directly? In a startup, this seems like a quick and easy solution, but as the system scales, problems appear that no one could have guessed.
In my talk, I'll share Solidgate's experience in transforming its architecture: from the chaos of direct connections to a service-based data access model. I will talk about the transition stages, bottlenecks, and how isolation affected infrastructure support. I will honestly show what worked and what didn't. In short, we will analyze the controversy of this talk.
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdf
Tech-ASan: Two-stage check for Address Sanitizer - Yixuan Cao.pdfcaoyixuan2019 A presentation at Internetware 2025.
Enhance GitHub Copilot using MCP - Enterprise version.pdf
Enhance GitHub Copilot using MCP - Enterprise version.pdfNilesh Gule Slide deck related to the GitHub Copilot Bootcamp in Melbourne on 17 June 2025
You are not excused! How to avoid security blind spots on the way to production
You are not excused! How to avoid security blind spots on the way to productionMichele Leroux Bustamante We live in an ever evolving landscape for cyber threats creating security risk for your production systems. Mitigating these risks requires participation throughout all stages from development through production delivery - and by every role including architects, developers QA and DevOps engineers, product owners and leadership. No one is excused! This session will cover examples of common mistakes or missed opportunities that can lead to vulnerabilities in production - and ways to do better throughout the development lifecycle.
The Future of Technology: 2025-2125 by Saikat Basu.pdf
The Future of Technology: 2025-2125 by Saikat Basu.pdfSaikat Basu A peek into the next 100 years of technology. From Generative AI to Global AI networks to Martian Colonisation to Interstellar exploration to Industrial Nanotechnology to Artificial Consciousness, this is a journey you don't want to miss. Which ones excite you the most? Which ones are you apprehensive about? Feel free to comment! Let the conversation begin!
The Future of AI Agent Development Trends to Watch.pptx
The Future of AI Agent Development Trends to Watch.pptxLisa ward The Future of AI Agent Development: Trends to Watch explores emerging innovations shaping smarter, more autonomous AI solutions for businesses and technology.
Smarter Aviation Data Management: Lessons from Swedavia Airports and Sweco
Smarter Aviation Data Management: Lessons from Swedavia Airports and SwecoSafe Software Managing airport and airspace data is no small task, especially when you’re expected to deliver it in AIXM format without spending a fortune on specialized tools. But what if there was a smarter, more affordable way?
Join us for a behind-the-scenes look at how Sweco partnered with Swedavia, the Swedish airport operator, to solve this challenge using FME and Esri.
Learn how they built automated workflows to manage periodic updates, merge airspace data, and support data extracts – all while meeting strict government reporting requirements to the Civil Aviation Administration of Sweden.
Even better? Swedavia built custom services and applications that use the FME Flow REST API to trigger jobs and retrieve results – streamlining tasks like securing the quality of new surveyor data, creating permdelta and baseline representations in the AIS schema, and generating AIXM extracts from their AIS data.
To conclude, FME expert Dean Hintz will walk through a GeoBorders reading workflow and highlight recent enhancements to FME’s AIXM (Aeronautical Information Exchange Model) processing and interpretation capabilities.
Discover how airports like Swedavia are harnessing the power of FME to simplify aviation data management, and how you can too.
Cluster-Based Multi-Objective Metamorphic Test Case Pair Selection for Deep N...
Cluster-Based Multi-Objective Metamorphic Test Case Pair Selection for Deep N...janeliewang985 the slides of the MP selection approach CMPS
You are not excused! How to avoid security blind spots on the way to production
You are not excused! How to avoid security blind spots on the way to productionMichele Leroux Bustamante
Monitoring Your ISP Using InfluxDB Cloud and Raspberry Pi
- 3. • Travel addict • Photography enthusiast • Tech interested • Robotics/Industrial engineer
- 4. Why are we here?
- 9. What is going on at my place?
- 11. Monitor internet speed day & night Collect data View data
- 12. Monitor internet speed day & night Collect data View data … and what can I do if I’m not at home?
- 13. NEED Measure Store Visualize Communication HOW-TO Raspberry Pi Spreadsheet Spreadsheet Not possible
- 14. PRO Easy to implement Low effort to present data CONS Local Requires PC to open file Writing data (concurrency) SD card corruption Need to find a better solution!
- 15. NEED Measure Store Visualize Communication HOW-TO Raspberry Pi InfluxDB Grafana Sense-hat Telegram
- 16. PRO Nothing to store locally Maintenance not on me! Possibility to learn flux! CONS Not much!! Time to switch to influxdb2!
- 17. Several options available Needed ▪ PublicAPI ▪ Scriptable ▪ Debian-like compatible Not needed ▪ 100% uptime ▪ Certification speedtest.net speedtest CLI
- 18. Time Series DB Needed ▪ Free ▪ Cloud based ▪ Public API Not needed ▪ 100% uptime ▪ Large storage influxdata cloud free tier
- 19. Dashboard Needed ▪ Free ▪ Cloud based ▪ Nice-looking ▪ App based (desiderata) Not needed ▪ 100% uptime ▪ Lots of dashboards Grafana cloud free
- 20. Somehow give fast feedback about my network Needed ▪ Free ▪ Request based ▪ Easy to implement Not needed ▪ 100% uptime telegram custom bot
- 21. Let’s look at the implementation
- 22. RaspberryPi #1 RaspberryPi #2 info: astro-pi.org
- 23. INTERACTIVE $ speedtest Speedtest by Ookla Server: <Server Name> (id = <Server ID>) ISP: <ISP> Latency: 6.87 ms (1.95 ms jitter) Download: 77.37 Mbps (data used: 62.7 MB) Upload: 19.98 Mbps (data used: 9.0 MB) Packet Loss: 0.0% Result URL: https://www.speedtest.net/result/c/<UUID> SCRIPTED $ speedtest --format json { "type": "result", "timestamp": "2021-04-07T18:00:00Z", "ping": { "jitter": 0.696, "latency": 6.645 }, "download": { "bandwidth": 7662563, "bytes": 47087360, "elapsed": 5914 }, "upload": { "bandwidth": 2197125, "bytes": 7004736, "elapsed": 3607 }, "packetLoss": 0, "isp": "<ISP>", "interface": { "internalIp": "<LAN ip>", "name": "<LAN interface name>", "macAddr": "<LAN interface MAC>", "isVpn": false, "externalIp": "<Public IP>" }, "server": { "id": <Server ID>, "name": "<Server Name>", "location": "<Server Location>", "valcountry": "Italy", "host": "<Server Host>", "port": 8080, "ip": "<Server IP>" }, "result": { "id": "<UUID>", "url": https://www.speedtest.net/result/c/<UUID>} }
- 24. [[outputs.influxdb_v2]] urls = [ "${SPEEDTEST_SERVERURL}" ] token = "${SPEEDTEST_TOKEN}" organization = "${SPEEDTEST_ORGANIZATION}" bucket = "${SPEEDTEST_BUCKET}" [[processors.converter]] [processors.converter.fields] string = [ "server_id", ] integer = [ "server_port", ] float = [ "download_bandwidth", "download_bytes", "download_elapsed", "upload_bandwidth", "upload_bytes", "upload_elapsed", "packetLoss", "ping_latency", "ping_jitter", ] [[inputs.exec]] interval = "15m" commands = [ "/usr/bin/speedtest --accept-license --accept-gdpr -f json", ] name_override="${SPEEDTEST_MEASUREMENT}" timeout = "60s" data_format = "json" json_time_format = "2006-01-02T15:04:05Z" json_time_key = "timestamp" tag_keys = [ "interface_externalIp", "interface_internalIp", "isp", "server_host" ] json_string_fields = [ "server_location", "server_name", "server_testcountry", "server_ip", "result_id", "result_url", ]
- 25. from(bucket: mybucket) |> range(start: v.timeRangeStart, stop: v.timeRangeStop) |> filter(fn: (r) => r["_measurement"] == mymeasurement and ( r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "ping_latency" ) ) |> keep(columns: ["_time", "_field", "_value"]) |> aggregateWindow(every: v.windowPeriod, fn: valmean, createEmpty: false) |> map(fn: (r) => ({ r with _value: if (r._field == "download_bandwidth" or r._field == "upload_bandwidth") then r._value * 8.0 else r._value }) )
- 27. from(bucket: mybucket) |> range(start: v.timeRangeStart, stop: v.timeRangeStop) |> filter(fn: (r) => r["_measurement"] == mymeasurement and ( r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "ping_latency" or r["_field"] == "server_name" or r["_field"] == "packetLoss" or r["_field"] == "server_location") ) |> pivot(rowKey:["_time"], columnKey:["_field"], valueColumn:"_value") |> group(columns: ["server_host"]) |> keep(columns: ["download_bandwidth", "upload_bandwidth", "ping_latency", "packetLoss", "server_location", "server_name", "serve r_host"]) |> reduce(identity: { server_name: "", server_location: "", valcount: 0.0, download_bandwidth: 0.0, upload_bandwidth: 0.0, ping_latency: 0.0, packet Loss: 0.0, }, fn: (r, accumulator) => ({ server_name: r.server_name, server_location: r.server_location, valcount: accumulator.valcount + 1.0, download_bandwidth: (r.download_bandwidth + accumulator.download_bandwidth * accumulator.valcount) / (accumulator.valcount + 1 .0), upload_bandwidth: (r.upload_bandwidth + accumulator.upload_bandwidth * accumulator.valcount) / (accumulator.valcount + 1.0), ping_latency: (r.ping_latency + accumulator.ping_latency * accumulator.valcount) / (accumulator.valcount + 1.0), packetLoss: (r.packetLoss + accumulator.packetLoss * accumulator.valcount) / (accumulator.valcount + 1.0), }) ) |> map(fn: (r) => ({ r with download_bandwidth: r.download_bandwidth * 8.0, upload_bandwidth: r.upload_bandwidth * 8.0 })) |> drop(columns: ["server_host"])
- 29. from(bucket: mybucket) |> range(start: v.timeRangeStart, stop: v.timeRangeStop) |> filter(fn: (r) => r["_measurement"] == mymeasurement and ( r["_field"] == "results_id" or r["_field"] == "server_name" or r["_field"] == "server_location" ) ) |> keep(columns: ["_time", "_field", "_value"]) |> sort(columns: ["_time"], desc: true)
- 31. import "experimental" import "date" option task = {name: "DailyMinMax", cron: "0 2 * * *"} today = () => (date.truncate(t: now(), unit: 1d)) yesterday = (boundary="start") => { timeValue = if boundary == "end" then experimental.subDuration(d: 1ns, from: today()) else experimental.subDuration(d: 24h, from: today()) return timeValue } from(bucket: mybucket) |> range(start: yesterday(), stop: yesterday(boundary: "end")) |> timeShift(duration: 1h, columns: ["_start", "_stop", "_time"]) |> filter(fn: (r) => (r["_measurement"] == mymeasurement and (r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "pingLatency"))) |> keep(columns: ["_time", "_field", "_value"]) |> reduce(identity: { valcount: 0.0, valmin: 0.0, valmax: 0.0, valmean: 0.0, }, fn: (r, accumulator) => ({ valcount: accumulator.valcount + 1.0, valmin: if accumulator.valcount == 0.0 then r._value else if r._value < accumulator.valmin then r._value else accumulator.valmin, valmax: if accumulator.valcount == 0.0 then r._value else if r._value > accumulator.valmax then r._value else accumulator.valmax, valmean: (r._value + accumulator.valmean * accumulator.valcount) / (accumulator.valcount + 1.0), })) |> map(fn: (r) => ({r with _time: yesterday(boundary: "end"), _measurement: "daily", data: r._field})) |> to( bucket: <mybucket>, org: <myorganization>, tagColumns: ["data"], fieldFn: (r) => ({ "valcount": r.valcount, "valmean": r.valmean, "valmin": r.valmin, "valmax": r.valmax, }))
- 34. Visual feedback Periodical & on-demand Python + AstroPi(kind-of) info: astro-pi.org [...] self.query = 'import "math" from(bucket: "' + self.bucket + '") |> range(start: -1d) |> filter(fn: (r) => r["host"] == "%s" and r["_measurement"] == "' + self.measurement + '" and ( r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "ping_latency" ) ) |> keep(columns: ["_time", "_field", "_value"]) |> sort(columns: ["_time"], desc: false) |> last() |> map(fn: (r) => ({ r with _value: if (r._field == "download_bandwidth" or r._field == "upload_bandwidth") then math.round(x: (r._value * 8.0 / 10000.0)) / 100.0 else r._value }) ) |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")' db_client = InfluxDBClient(url=self.url, token=self.token, org=self.org) db_data = db_client.query_api().query_stream(query=(self.query_string % hostsname), org=self.org) [...]
- 35. Visual feedback Periodical & on-demand Python + AstroPi(kind-of) info: astro-pi.org [...] self.query = 'import "math" from(bucket: "' + self.bucket + '") |> range(start: -1d) |> filter(fn: (r) => r["host"] == "%s" and r["_measurement"] == "' + self.measurement + '" and ( r["_field"] == "download_bandwidth" or r["_field"] == "upload_bandwidth" or r["_field"] == "ping_latency" ) ) |> keep(columns: ["_time", "_field", "_value"]) |> sort(columns: ["_time"], desc: false) |> last() |> map(fn: (r) => ({ r with _value: if (r._field == "download_bandwidth" or r._field == "upload_bandwidth") then math.round(x: (r._value * 8.0 / 10000.0)) / 100.0 else r._value }) ) |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")' db_client = InfluxDBClient(url=self.url, token=self.token, org=self.org) db_data = db_client.query_api().query_stream(query=(self.query_string % hostsname), org=self.org) [...]
- 36. PROS Something quick and easy On demand Custom telegram bot on Raspberry Pi CONS No slack app & workspace No live notifications (yet) No service in case of network issues
- 37. PROS Something quick and easy On demand Custom telegram bot on Raspberry Pi CONS No slack app & workspace No live notifications (yet) No service in case of network issues
- 44. Do not use random test server Select optimal test server Use good hardware at home
- 45. Integration with Smart Speakers (?) Automatic daily reporting Event notifications …
- 47. We look forward to bringing together our community of developers to learn, interact and share tips and use cases. 10-11 May 2021 Hands-On Flux Training 18-19 May 2021 Virtual Experience www.influxdays.com/emea-2021-virtual-experience/