How To Integrate Ruby with Logit.io

What is Ruby?

Ruby is an open-source programming language intended to be simple and productive, with an elegant syntax that is easy to read and write. A key feature of Ruby is that it is completely object-oriented. In Ruby, everything, from integers to strings, represents an 'object'. It also provides a consistent and easy-to-understand approach to programming where the same paradigm is applied to all aspects.

The tool enhances the developer's productivity and enjoyment by using human-friendly and flexible syntax rather than employing strict rules. These design philosophies make Ruby excellent for new and experienced programmers who like a language that will stay out of their way so they can solve problems.

Ruby vs Python

Both Ruby and Python are popular programming languages that are clean, readable, and open-sourced. They are high-level, back-end languages used to build the required server functions to support the application’s front end. While these tools share similar features they have differences that lend to one solution being more appropriate for certain applications.

Similarities

To begin with, in analyzing Ruby vs Python for similarities, both languages prioritize simplicity and readability, making them accessible for beginners and powerful for developers. Python is straightforward in the way its syntax is formed, it is hailed for being clear and similar to what humans can read as a natural language. Ruby is focused on being human-centric in its coding, which translates to simplicity and productivity. The readability in both languages evokes good coding etiquette and minimizes the learning curve.

Moreover, both Python and Ruby are object-oriented languages. In Python, everything is an object, even functions and classes, which supports a wide spectrum of programming paradigms. Ruby offers much more concerning object orientation, it has nearly every value of an object and was constructed with a strong bearing from this paradigm. Python and Ruby’s deep commitment to object-oriented programming permits elegant and modular code in both languages, encouraging reusability and maintenance.

In addition, both Python and Ruby are heavily used for web development, running strong on frameworks that will ease the creation process of web apps. Python comes with frameworks such as Django and Flask, while Ruby is synonymous with Ruby on Rails, one of the initial foundational frameworks that influenced many of the current web development best practices. These frameworks allow developers to prototype and develop full-featured web apps quickly, with fewer lines of code and less effort.

Differences

Reviewing Ruby vs Python for key differences, firstly, Python is a general-purpose language with extensive usage in different domains. It can be applied to data science, artificial intelligence, kindred pursuits, automation, and web development. The simplicity and readability of Python make it well-suited to scripting, automation, and rapid prototyping. Its wide range of applications makes it one of the ‘go-to’ languages for most projects, from simple scripts to complex applications.

Primarily, Ruby has been utilized to develop web applications, with the most prominent being Ruby on Rails. Rails laid a foundation for several web startups and remains one of the favorites for fast web application development. Use cases of Ruby besides web development are relatively fewer, but it is also found in scripting, automation, and some DevOps tools. Ruby is renowned for how productive and easy it is to build web applications quickly and effectively.

Also, Python's syntax has been labeled minimalist and clean. Readability is its principal objective, and it uses a clean language syntax that is pleasurable to read and write. For example, Python uses indentation to define code blocks, making the enforcement of a consistent style and reducing the possibility of syntax errors intrinsic to the process. Perhaps because Python's standard for syntax is consistent across different use cases, it has gained the reputation of a language that users can rely on. Thanks to this predictability and uniformity, Python has grown to be among the best languages for collaborative projects and large codebases.

Ruby, in contrast, has more flexible syntax and allows for a greater degree of expressiveness. Ruby does not force through indentation or other strict rules on how a developer should format their code. It can provide more elegance and conciseness of code, mainly in complex cases. However, it also risks having different styles of coding within the same project that may complicate maintenance. Ruby's syntax is designed to be natural, to mirror the English language as much as possible, hence contributing to its goals of being intuitive and easy to use.

Why Use Ruby for Application Performance Monitoring (APM)?

Opting for any technology to conduct application performance monitoring (APM) is often driven by the language or framework that was used to develop your application, and this is no different with Ruby. From choosing Ruby to build your application you can gain numerous advantages when conducting APM.

Firstly, Ruby's dynamic nature makes it easy to customize APM solutions for the unique requirements of your application. Whether you need to perform instrumentation of particular parts of your code, create custom metrics, or adjust how data is collected and reported, Ruby enables high levels of customization.

Additionally, Ruby has a clean and intuitive syntax that can help developers easily implement and maintain performance monitoring. In this way, the time spent on setting up and managing APM is radically decreased. Your team can easily shift their focus from wrestling with complex configurations to performance optimization to better assist the organization.

Lastly, an active and supportive community in Ruby means that there are many resources for troubleshooting, optimizing, and extending APM capabilities. This is possible through open-source contributions, community forums, or highly detailed documentation, all of which can help a Ruby developer in times of need. This paired with Logit.io’s extensive documentation and highly-rated customer support ensures if you encounter any issues you can promptly find a solution.

APM from Logit.io

Logit.io provides a powerful and cost-effective application performance monitoring (APM) solution, specifically designed for Ruby applications. Our platform offers open APM and trace analytics without vendor lock-in or data egress fees and clear, transparent billing.

Built on a foundation of open-source technologies, Logit.io’s APM tool incorporates the ELK Stack and Grafana. These tools deliver comprehensive log, metrics, and trace analytics essential for effective application monitoring and optimization. To learn more about Logit.io’s APM capabilities, contact us or start your 14-day free trial to explore the platform firsthand.

How to Use OpenTelemetry to Ship Ruby Traces to Logit.io

We have produced a detailed integration guide that offers simple steps to walk you through the process of configuring Ruby with OpenTelemetry to ship traces to OpenSearch, enabling you to begin viewing these traces in Logit.io APM.

Using OpenTelemetry to send Ruby traces offers several advantages, especially in modern, distributed systems where monitoring and observability are crucial. OpenTelemetry is an open-source, vendor-agnostic instrumentation library used for generating and collecting traces, metrics, and logs in several programming languages and environments. Instrumenting with OpenTelemetry in Ruby ensures conformance of your tracing data to a highly adoptable standard, guaranteeing ease of integration with other tools and platforms in Observability.

Also, The Ruby SDK for OpenTelemetry was created with a focus on making integrations into applications easier. It provides auto-instrumentation for Ruby's most popular frameworks, such as Rails and Sinatra, and reduces the majority of manual input for instrumentation, which captures traces. It makes your life easier and speeds up the adoption of tracing in your app without requiring too much change in your source code.

Below we’ve listed the steps required to begin using OpenTelemetry to send Ruby traces to Logit.io.

1. Install

Create a new directory for your project and call the new directory opentelemetry_example.

Open a Terminal window or Command Prompt and navigate into the new opentelemetry_example directory. Then enter the following command.

    bundle init

You will now see a Gem file has been created inside the folder.

Create two new files in the folder and call them app.rb and config.rb. There should now be a total of three files in the opentelemetry_example folder.

2. Configure the App

Open the Gem file and paste in the following code, overwriting the existing content.

# frozen_string_literal: true

source 'http://www.rubygems.org'

# gem "rails"

gem 'opentelemetry-sdk'
gem 'opentelemetry-exporter-otlp'
gem 'opentelemetry-instrumentation-all'

Install the Gems with the following command in Terminal or the Command prompt.

bundle install

3. Using OpenTelemetry

Copy and Paste the code below into config.rb.

Tip: You will need to update any placeholder variables with your OpenTelemetry details.

config.rb
# config.rb

# Define variables
OTLP_ENDPOINT_URL = "https://<your-otel-endpoint-address>"
PORT = "<your-otel-endpoint-https-port>"
OTLP_USERNAME = "<your-otel-username>"
OTLP_PASSWORD = "<your-otel-password>"

Finally, copy and paste the code below into app.rb

app.rb
# app.rb

require_relative 'config'

require "sinatra"
require 'opentelemetry/sdk'
require 'opentelemetry/exporter/otlp'
require 'base64'

# Configuration Parameters
ENV['OTEL_EXPORTER_OTLP_ENDPOINT'] = "#{OTLP_ENDPOINT_URL}:#{PORT}"
ENV['OTEL_EXPORTER_OTLP_HEADERS'] = "Authorization = Basic " + Base64.strict_encode64("#{OTLP_USERNAME}:#{OTLP_PASSWORD}")
ENV['OTEL_SERVICE_NAME'] = "LogitTestApp"

# Configure the OpenTelemetry SDK with OTLP Exporter
OpenTelemetry::SDK.configure do |c|
  c.use_all() # Enable all available instrumentation
end

# Endpoint to be called to add traces
get "/" do
 tracer = OpenTelemetry.tracer_provider.tracer('LogitTestService')

 # Start the first span
tracer.in_span('Logit Span Test') do |span|
  span.set_attribute('First Message', 'This is a test!')
  span.set_attribute('Second Message', 'Message sent at ' + Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S'))

  # Start the second span within the context of the first span
  tracer.in_span('Logit Span Test 2') do |child_span|
    child_span.set_attribute('First Message', 'This is another test!')
    child_span.set_attribute('Second Message', 'Message sent at ' + Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S'))
  end
end

end

# Message when starting app
puts "Starting Logit Test App"

4. Run the Ruby App

Run the Ruby app with the following command in Terminal or the Command Prompt window.

ruby app.rb

You will see feedback from the app so that you know that it is running, make a note of the endpoint that it is listening on.

Open a new Terminal or Command Prompt window and make a curl request to the listening endpoint

curl http://127.0.0.1:4567

Traces will now have been sent to your Stack.

Visualize Ruby Metrics in Logit.io

The Logit.io platform offers numerous open-source tools as hosted solutions, one of which is Hosted Jaeger. With Hosted Jaeger you completely remove the complexities involved in setting up Jaeger from scratch, such as configuring multiple components such as agents, collectors, storage backends, and the UI. Also, by using Jaeger you can gain from powerful visualization tools that allow you to explore trace data interactively. As well as this, the solution is highly scalable and effectively handles large volumes of tracing data generated by highly distributed systems.

To visualize Ruby metrics and traces in Logit.io, you will first need to have configured Ruby to send data to Logit.io by following the steps in our configuration guide. To start with ‘visualizers’ for Ruby traces, we recommend using Jaeger which can be launched from the ‘Application Performance Monitoring’ section.

1. Launch APM: From the initial dashboard, scroll down to the Application Performance Monitoring (APM) section, and under ‘Services’ you’ll see Jaeger, select ‘Launch’, or in the top right of your screen select ‘Launch APM’

2. Jaeger: After selecting ‘Launch APM’ or ‘Launch’ you will arrive at the Jaeger UI search page.

3. Visualize Ruby Data: From this page, you can view all your ingested Ruby traces, Hosted Jaeger enables you to drill down into specific traces, view service dependencies, analyze latency distributions, and more, making it easier to pinpoint the root causes of performance issues.

If you've enjoyed this article why not read How To Integrate Serilog with Logit.io or How To Integrate Python with Logit.io next?