$parameter-name$
We’re excited to announce that Lumigo Copilot is now in open beta — available to all users! 🎉
You can now chat with Copilot directly from the invocation or transaction page to:
Ask questions about traces from the past 14 days, including:
Copilot helps you get answers faster and streamline your debugging workflow. Give it a try!
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.
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!
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.
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();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!
Well, we are just getting started. There is some really interesting stuff happening with Lumigo in and beyond Serverless in the next few months ;-)
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.
Amazon Elastic Container Service (ECS) monitoring is now generally available in Lumigo.
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.
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.
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.
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:
To learn more about the new Transaction view, read the documentation.
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.
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!
For more information visit our Stackoscope page and check out the blog post written by Yan Cui, the chief creator of Stackoscope.