codefromthecrypt

Check out the PR branch, then update the tree of deps in one of the examples like this in requirements.txt

openai~=1.63.2

opentelemetry-api@git+https://github.com/open-telemetry/opentelemetry-python.git#egg=opentelemetry-api&subdirectory=opentelemetry-api
opentelemetry-sdk@git+https://github.com/open-telemetry/opentelemetry-python.git#egg=opentelemetry-sdk&subdirectory=opentelemetry-sdk
opentelemetry-semantic-conventions@git+https://github.com/open-telemetry/opentelemetry-python.git#egg=opentelemetry-semantic-conventions&subdirectory=opentelemetry-semantic-conventions
opentelemetry-proto@git+https://github.com/open-telemetry/opentelemetry-python.git#egg=opentelemetry-proto&subdirectory=opentelemetry-proto
opentelemetry-exporter-otlp-proto-common@git+https://github.com/open-telemetry/opentelemetry-python.git#egg=opentelemetry-exporter-otlp-proto-common&subdirectory=exporter/opentelemetry-exporter-otlp-proto-common

codefromthecrypt

(module $env
  ;; import and re-export logstr. the exported function has the same signature
  ;; and passes the parameters via local.get 0..n
  (import "host" "logstr" (func $logstr (param i32)))
  (func (export "logstr") (param i32)
    (call $logstr (local.get 0)))

  (memory (export "memory") 1)
)

codefromthecrypt

karmem api;

struct ManagedFieldData table {
    ApiVersion []char;

    FieldsType []char;

    Manager []char;

    Operation []char;

codefromthecrypt

#include <stdlib.h>

/* define a dynamic function */
int (*dynamicInt)();

/* import a function from the host */
extern int hostInt();
/* assign it to the next table offset (0) */
int (*hostIntPtr)() = &hostInt;

codefromthecrypt

From https://github.com/tetratelabs/wazero/runs/6473296164?check_suite_focus=true

BenchmarkAllocation/Call-16
wazero-compiler 14039.84  ns/op
wasmedge        264615.55 ns/op
BenchmarkFactorial/Call-16
wazero-compiler 1600.76  ns/op
wasmedge        14359.72 ns/op
BenchmarkAllocation/Compile-2         	 3293992	       358.9 ns/op
BenchmarkAllocation/Instantiate-2     	     391	   3081906 ns/op

codefromthecrypt

package main

import (
	"context"
	_ "embed"
	"fmt"
	"log"

	"github.com/tetratelabs/wazero"
	"github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1"

codefromthecrypt

import io.opentelemetry.common.AttributeValue;
import io.opentelemetry.exporters.logging.LoggingSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Tracer;

// This shows how you can add attributes to a span and print it to console using Java's logger.
//
// $ java -cp snark.jar Snark

codefromthecrypt

2020-03-25 09:14:06.293  INFO 22055 --- [-worker-nio-2-1] c.l.a.c.l.LoggingClient                  : Request: {startTime=2020-03-25T01:14:06.287Z(1585098846287794), length=0B, duration=483µs(483304ns), scheme=none+h1c, headers=[:method=GET, :path=/, :authority=localhost:9200, :scheme=http, accept-encoding=gzip,deflate, user-agent=armeria/0.97.0]}
2020-03-25 09:14:06.344  INFO 22055 --- [-worker-nio-2-1] c.l.a.c.l.LoggingClient                  : Response: {startTime=2020-03-25T01:14:06.315Z(1585098846315931), length=333B, duration=28087µs(28087280ns), headers=[:status=200, content-type=application/json; charset=UTF-8, content-encoding=gzip, content-length=333], content={
  "name" : "MacBook-Pro-8.local",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "t12hyJk4RwCyYK7Av7oz3Q",
  "version" : {
    "number" : "7.6.1",
    "build_flavor" : "default",
    "build_type" : "tar",
    "build_hash" : "aa751e09be0a5072e8570670309b1f12348f023b",

codefromthecrypt

I've been very obsessed with the duration of Zipkin's POST endpoint, more than how many bytes of memory are used while processing a POST (I also obsess about that, but it doesn't keep me up at night). The duration of an endpoint that receives telemetry data, is the part that you can control of the response time.

Callers of Zipkin's POST endpoint are usually little http loops inside an application. Even when these are done neatly, with bounds etc, blocking those loops causes damage (lost spans), and also causes more overhead as these queues fill to capacity. Crazy, but true.. sometimes people literally POST to zipkin inline (ad-hoc or sometimes in php)! While we shouldn't optimize for this, it is crazy the amount of impact you can do.

For this reason, we need to succeed fast, and we also need to fail fast. We want these things to clear or fail quickly (ex in case of failure, the client can try another node, right?). This "fast" must apply at reasonable percentage of requests, because you don't want half your

codefromthecrypt

In the last 4 years I've noticed an increase in marketing things vs making them better. Here are some tricks I've learned about and am now more wary about. Purely my own opionions as an open source person.

My company made X (but they didn't)

We know it is often the case that ideas are not executed, or poorly executed. When people quit google to make a startup competing with their employer, it is tempting to claim they invented something invented at google. You can tell this when people clarify that they "really made" X. This hints they didn't make it. Regardless of who invented something, there is value in popularizing it (provided the "it" was a good idea). There's possibly most value in enduring it through support.

It can be strange that a big company would allow a small company to literally compete with them and misattribute simultaneously. First, check to see if it is california, if so, that's probably the answer :) Also, a big company maybe doesn't want the publicity of picking on a smaller one, or