Lumigo Release Notes logo

Release Notes

Back to Homepage Subscribe to Updates

Labels

  • All Posts
  • Announcement
  • feature
  • Improvement

Jump to Month

  • June 2024
  • April 2024
  • January 2024
  • October 2023
  • July 2023
  • June 2023
  • May 2023
  • April 2023
  • December 2022
  • November 2022
  • October 2022
  • September 2022
  • August 2022
  • July 2022
  • June 2022
  • May 2022
  • April 2022
  • February 2022
  • November 2021
  • September 2021
  • August 2021
  • July 2021
  • June 2021
  • May 2021
  • April 2021
  • March 2021
  • February 2021
Announcement
2 years ago

The Lumigo Kubernetes Operator: tracing applications on Kubernetes has never been easier!

Kubernetes is the container orchestration platform of choice for many teams. In our ongoing efforts to bring the magic experience of Lumigo’s serverless capabilities to the world of containerized applications, we are delighted to share with you the Lumigo Kubernetes operator, a best-in-class operator to automatically trace your applications running on Kubernetes using the Lumigo OpenTelemetry distributions for Java, Node.js and Python.

We designed the Lumigo Kubernetes operator with ease of use and automation in mind: to get your applications traced with Lumigo on Kubernetes, all you have to do is install the Lumigo Kubernetes operator with Helm, and then create in the namespaces where you want applications traced, a Lumigo resource:

apiVersion: v1
kind: Secret
metadata:
name: lumigo-credentials
stringData:
# Kubectl won't allow you to deploy this dangling anchor.
# Get the actual value from Lumigo following this documentation: https://docs.lumigo.io/docs/lumigo-tokens
token: *lumigo-token # Example: t_123456789012345678901
---
apiVersion: operator.lumigo.io/v1alpha1
kind: Lumigo
metadata:
labels:
app.kubernetes.io/name: lumigo
app.kubernetes.io/instance: lumigo
app.kubernetes.io/part-of: lumigo-operator
name: lumigo
spec:
lumigoToken:
secretRef:
name: lumigo-credentials # This must match the name of the secret; the secret must be in the same namespace as this Lumigo custom resource
key: token # This must match the key in the Kubernetes secret

(You find your Lumigo token in your Lumigo project.)

The Lumigo Kubernetes operator will update your deployments, daemonsets, replicasets, statefulsets, cronjobs and jobs to be traced with the Lumigo OpenTelemetry Distro for Java, Lumigo OpenTelemetry Distro for Node.js and Lumigo OpenTelemetry Distro for Python.

Monitoring applications on Kubernetes has never been easier ;-)

For more details on how to use the Lumigo Kubernetes Operator, refer to the documentation on GitHub. And if you are curios about how we managed to make it so easy, we have an in-depth look at the magic behind the Lumigo Kubernetes operator waiting for you on the Lumigo blog.

Announcement
2 years ago

Official Lumigo construct for AWS CDK 2

The AWS Cloud Development Kit (CDK) enables you to define your cloud application resources using familiar programming languages, mixing an imperative programming style with the declarative nature of the underpinning AWS CloudFormation.

Today, we are launching @lumigo/cdk-constructs-v2: 1st-party, officially supported constructs to add Lumigo autotracing for your Lambda functions in CDK applications!

What is supported today?

The Lumigo construct can add Lumigo autotracing to all your Node.js and Python Lambda functions in a CDK app:

import { Lumigo } from '@lumigo/cdk-constructs-v2';
import { App, SecretValue } from 'aws-cdk-lib';

const app = new App();

// Add here stacks and constructs

new Lumigo({lumigoToken:SecretValue.secretsManager('LumigoToken')}).traceEverything(app);

app.synth();

Tracing can also be added to all Lambda functions in a stack:

import { Lumigo } from '@lumigo/cdk-constructs-v2';
import { App, SecretValue } from 'aws-cdk-lib';

export class NodejsStack extends Stack {

  constructor(scope: Construct, id: string, props: StackProps = {}) {
    super(scope, id, props);

      new Function(this, 'MyLambda', {
        code: new InlineCode('foo'),
        handler: 'index.handler',
        runtime: Runtime.NODEJS_14_X,
      });
    }

}

const app = new App();

const stack = new NodejsStack(app, 'NodejsTestStack', {
  env: {
    region: 'eu-central-1',
  }
}); 

new Lumigo({lumigoToken:SecretValue.secretsManager('LumigoToken')}).traceEverything(stack);

app.synth();

You can also add tracing to Lambda functions one by one:

import { Lumigo } from '@lumigo/cdk-constructs-v2';
import { App, SecretValue } from 'aws-cdk-lib';
interface NodejsStackProps extends StackProps {
  readonly lumigo: Lumigo;
}
export class NodejsStack extends Stack {
    constructor(scope: Construct, id: string, props: NodejsStackProps = {}) {
        super(scope, id, props);
        const handler = new Function(this, 'MyLambda', {
            code: new InlineCode('foo'),
            handler: 'index.handler',
            runtime: Runtime.NODEJS_14_X,
        });
        props.lumigo.traceLambda(handler);
    }
}
const app = new App();

const lumigo = new Lumigo({lumigoToken:SecretValue.secretsManager('LumigoToken')});

const stack = new NodejsStack(app, 'NodejsTestStack', {
    env: {
        region: 'eu-central-1',
    },
    lumigo,
}); 

app.synth();

Autotracing can be added to all Lambda functions declared as a Function from the aws-cdk-lib/aws-lambda package with a Node.js or Python runtime, NodejsFunction from the aws-cdk-lib/aws-lambda-nodejs and PythonFunction from the @aws-cdk/aws-lambda-python-alpha package.

Which version of the tracer will be used?

Each version of the @lumigo/cdk-constructs-v2 package comes with a built-in list of latest Lambda layers as of the time of publishing. We regularly (in a matter of hours) publish new versions of the @lumigo/cdk-constructs-v2 package when we release a new layer. Reproducibility is very important for AWS CDK apps, and that is why the same version of the @lumigo/cdk-constructs-v2 will always generate the same CloudFormation. (Moreover, it is bad practice to invoke APIs during the "synth" phase in CDK.) So, to get the newest tracers deployed, update the version of the @lumigo/cdk-constructs-v2 package and run "cdk deploy" anew.

It also possible for you to manually specify which version of the layer to use:

import { Lumigo } from '@lumigo/cdk-constructs-v2';
import { App, SecretValue } from 'aws-cdk-lib';

const app = new App();
// Add here stacks and constructs

new Lumigo({lumigoToken:SecretValue.secretsManager('LumigoToken')}).traceEverything(app, {
    lambdaNodejsLayerVersion: 42,  // All Lambda functions with a supported Node.js runtime will use the layer v42
    lambdaPythonLayerVersion: 1,  // All Lambda functions with a supported Python runtime will use the layer v1
});

app.synth();

Why using a CDK construct when Lumigo has autotracing in the UI?

You can indeed ask Lumigo to autotrace functions you manage with any of the tools out there that rely on CloudFormation (CDK itself, the Serverless framework, the AWS Serverless Application Model), but some may find that having Lumigo change infrastructure after deployment is not ideal in Infrastructure as Code (IaC) approaches. So, we are making it straightforward to add Lumigo tracing as an integral part of your IaC specification. This is why we built the Lumigo Serverless plugin before, and we are releasing the Lumigo CDK constructs today!

Isn't 'Lumigo.traceEverything' a little bold as an API name? After all, it's only Lambda, no?

Well, we are just getting started. There is some really interesting stuff happening with Lumigo in and beyond Serverless in the next few months ;-)

Credits

Special thanks to Thorsten Höger of Taimos, AWS DevTools Hero and author of "The CDK Book", for his invaluable feedback during the ideation and first implementation of the @lumigo/cdk-constructs-v2 package.

Thorsten offers various service packages to help you level up your CDK usage, offers reviews of your CDK apps, and runs the Cloud Automation Weekly podcast, where I had the pleasure to be his first guest, discussing how I use daily AWS CDK in my Product Management work at Lumigo.

Announcement
2 years ago

Support for Amazon ECS is live!

Amazon Elastic Container Service (ECS) monitoring is now generally available in Lumigo.

ECS Dashboards

The Clusters view gives you an overview of your ECS clusters, the trends of usage of their resources, and you can jump with a click into the traces running through those clusters.

The Services view provides you with an overview of the ECS services on a cluster, including their status, launch type, CPU or memory utilization trends, deployment configuration. With one click, you can jump to the traces involving each service.

The Tasks view offers an overview of the tasks on a cluster or a service, including their status, launch type, resource limits, and the corresponding traces.

New default dashboards

With the arrival of containers in Lumigo, we touched up the default dashboard to show also information about your containerized workloads. These changes are visible only in the Lumigo projects that have not customized their default dashboard.

Distributed tracing with OpenTelemetry

The distributed tracing of containerized applications on Amazon ECS is powered by OpenTelemetry. We published two OpenTelemetry distributions for Node.js and Python, and Lumigo can now ingest distributed-tracing data from any OpenTelemetry SDK via its new OTLP+HTTP endpoint.


Announcement
3 years ago

New and improved Transaction view

The updated Transaction view contains the same valuable information that helps you find and fix issues in seconds, but now with an updated UI to offer a best-in-class visual debugging experience and added functionality:

  • Zoom in and out of timeline
  • A dedicated tab for logs

To learn more about the new Transaction view, read the documentation.

Announcement
3 years ago

Real-Time debugging with Live-Tail

We are thrilled to announce the general availability of Lumigo Live-Tail for tailing all your Lambda functions invocations in real-time. Live-Tail adds a much-required serverless debugging functionality and is now part of Lumigo's observability platform.

Live-Tail mimics a rolling log of your entire system, but instead of logs, it captures all your lambda invocations in real-time and easily views your logs, event, execution tags, and more details.

For more information read the documentation here.

Announcement
4 years ago

Introducing Stackoscope - Detect Early, Fix Quickly

We're thrilled to announce the release of Stackoscope, a free tool that runs a health check on your #AWS serverless environments with a single CLI command!

  • Detect bottlenecks and other performance issues in your stack
  • Know serverless best practices and how they can be applied to your environment
  • Detect misconfigurations early

For more information visit our Stackoscope page and check out the blog post written by Yan Cui, the chief creator of Stackoscope.