prometheus-client-mmap 0.28.1-aarch64-linux → 1.0.0-aarch64-linux

data/ext/fast_mmaped_file/fast_mmaped_file.c

@@ -1,122 +0,0 @@
-#include <errno.h>
-#include <hashmap.h>
-#include <jsmn.h>
-#include <ruby.h>
-#include <ruby/intern.h>
-#include <sys/mman.h>
-
-#include "file_parsing.h"
-#include "file_reading.h"
-#include "globals.h"
-#include "mmap.h"
-#include "rendering.h"
-#include "utils.h"
-#include "value_access.h"
-
-VALUE MMAPED_FILE = Qnil;
-
-ID sym_min;
-ID sym_max;
-ID sym_livesum;
-ID sym_gauge;
-ID sym_pid;
-ID sym_samples;
-
-VALUE prom_eParsingError;
-
-int aggregate_files(struct hashmap *map, VALUE list_of_files) {
-    buffer_t reading_buffer;
-    memset(&reading_buffer, 0, sizeof(buffer_t));
-
-    for (int i = 0; i < RARRAY_LEN(list_of_files); i++) {
-        VALUE params = RARRAY_PTR(list_of_files)[i];
-        file_t file;
-
-        if (!file_open_from_params(&file, params)) {
-            buffer_dispose(&reading_buffer);
-            return 0;
-        }
-
-        if (!read_from_file(&file, &reading_buffer)) {
-            buffer_dispose(&reading_buffer);
-            file_close(&file);
-            return 0;
-        }
-
-        if (!process_buffer(&file, &reading_buffer, map)) {
-            buffer_dispose(&reading_buffer);
-            file_close(&file);
-            return 0;
-        }
-
-        if (!file_close(&file)) {
-            buffer_dispose(&reading_buffer);
-            return 0;
-        }
-    }
-
-    buffer_dispose(&reading_buffer);
-    return 1;
-}
-
-VALUE method_to_metrics(VALUE UNUSED(self), VALUE file_list) {
-    struct hashmap map;
-    hashmap_setup(&map);
-
-    if (!aggregate_files(&map, file_list)) {  // all entries in map are now copies that need to be disposed
-        hashmap_destroy(&map);
-        raise_last_exception();
-        return Qnil;
-    }
-
-    entry_t **sorted_entries;
-
-    if (!sort_map_entries(&map, &sorted_entries)) {
-        hashmap_destroy(&map);
-
-        raise_last_exception();
-        return Qnil;
-    }
-
-    VALUE rv = rb_str_new("", 0);
-    if (!entries_to_string(rv, sorted_entries, hashmap_size(&map))) {
-        free(sorted_entries);
-        hashmap_destroy(&map);
-
-        raise_last_exception();
-        return Qnil;
-    }
-
-    RB_GC_GUARD(file_list);  // ensure file list is not GCed before this point
-    free(sorted_entries);
-    hashmap_destroy(&map);
-    return rv;
-}
-
-void Init_fast_mmaped_file() {
-    sym_gauge = rb_intern("gauge");
-    sym_min = rb_intern("min");
-    sym_max = rb_intern("max");
-    sym_livesum = rb_intern("livesum");
-    sym_pid = rb_intern("pid");
-    sym_samples = rb_intern("samples");
-
-    prom_eParsingError = rb_define_class("PrometheusParsingError", rb_eRuntimeError);
-
-    MMAPED_FILE = rb_define_class("FastMmapedFile", rb_cObject);
-    rb_define_const(MMAPED_FILE, "MAP_SHARED", INT2FIX(MAP_SHARED));
-
-    rb_define_singleton_method(MMAPED_FILE, "to_metrics", method_to_metrics, 1);
-
-    rb_define_alloc_func(MMAPED_FILE, mm_s_alloc);
-    rb_define_singleton_method(MMAPED_FILE, "new", mm_s_new, -1);
-    rb_define_method(MMAPED_FILE, "initialize", mm_init, 1);
-    rb_define_method(MMAPED_FILE, "slice", mm_aref_m, -1);
-    rb_define_method(MMAPED_FILE, "sync", mm_msync, -1);
-    rb_define_method(MMAPED_FILE, "munmap", mm_unmap, 0);
-
-    rb_define_method(MMAPED_FILE, "used", method_load_used, 0);
-    rb_define_method(MMAPED_FILE, "used=", method_save_used, 1);
-    rb_define_method(MMAPED_FILE, "fetch_entry", method_fetch_entry, 3);
-    rb_define_method(MMAPED_FILE, "upsert_entry", method_upsert_entry, 3);
-}

data/ext/fast_mmaped_file/file_format.c

@@ -1,5 +0,0 @@
-#include "file_format.h"
-
-inline uint32_t padding_length(uint32_t key_length) {
-    return 8 - (sizeof(uint32_t) + key_length) % 8;  // padding | 8 byte aligned
-}

data/ext/fast_mmaped_file/file_format.h

@@ -1,11 +0,0 @@
-#ifndef FILE_FORMAT_H
-#define FILE_FORMAT_H
-
-#include <stdint.h>
-
-#define START_POSITION 8
-#define INITIAL_SIZE (2 * sizeof(int32_t))
-
-uint32_t padding_length(uint32_t key_length);
-
-#endif

data/ext/fast_mmaped_file/file_parsing.c

@@ -1,195 +0,0 @@
-#include "file_parsing.h"
-
-#include <hashmap.h>
-#include <jsmn.h>
-
-#include "file_format.h"
-#include "globals.h"
-#include "utils.h"
-
-HASHMAP_FUNCS_CREATE(entry, const entry_t, entry_t)
-
-typedef int (*compare_fn)(const void *a, const void *b);
-
-static size_t hashmap_hash_entry(const entry_t *entry) { return hashmap_hash_string(entry->json); }
-
-static int hashmap_compare_entry(const entry_t *a, const entry_t *b) {
-    if (a->json_size != b->json_size) {
-        return -1;
-    }
-
-    if (is_pid_significant(a) && (rb_str_equal(a->pid, b->pid) == Qfalse)) {
-        return -1;
-    }
-
-    return strncmp(a->json, b->json, a->json_size);
-}
-
-static void entry_free(entry_t *entry) {
-    free(entry->json);
-    free(entry);
-}
-
-static inline double min(double a, double b) { return a < b ? a : b; }
-
-static inline double max(double a, double b) { return a > b ? a : b; }
-
-static void merge_entry(entry_t *found, const entry_t *entry) {
-    if (entry->type == sym_gauge) {
-        if (entry->multiprocess_mode == sym_min) {
-            found->value = min(found->value, entry->value);
-        } else if (entry->multiprocess_mode == sym_max) {
-            found->value = max(found->value, entry->value);
-        } else if (entry->multiprocess_mode == sym_livesum) {
-            found->value += entry->value;
-        } else {
-            found->value = entry->value;
-        }
-    } else {
-        found->value += entry->value;
-    }
-}
-
-void merge_or_store(struct hashmap *map, entry_t *entry) {
-    entry_t *found = entry_hashmap_get(map, entry);
-    if (found) {
-        merge_entry(found, entry);
-        entry_free(entry);
-    } else {
-        entry_hashmap_put(map, entry, entry);  // use the hashmap like hashset actually
-    }
-}
-
-entry_t *entry_new(buffer_t *source, uint32_t pos, uint32_t encoded_len, file_t *file_info) {
-    entry_t *entry = calloc(1, sizeof(entry_t));
-    if (entry == NULL) {
-        return NULL;
-    }
-
-    entry->json = malloc(encoded_len + 1);
-    if (entry->json == NULL) {
-        free(entry);
-        return NULL;
-    }
-
-    memcpy(entry->json, source->buffer + pos, encoded_len);
-    entry->json[encoded_len] = '\0';
-    entry->json_size = encoded_len;
-
-    entry->pid = file_info->pid;
-    entry->multiprocess_mode = file_info->multiprocess_mode;
-    entry->type = file_info->type;
-
-    char *value_ptr = source->buffer + pos + encoded_len + padding_length(encoded_len);
-    memcpy(&(entry->value), value_ptr, sizeof(double));
-
-    return entry;
-}
-
-static int add_parsed_name(entry_t *entry) {
-    jsmn_parser parser;
-    jsmn_init(&parser);
-
-    jsmntok_t tokens[2];
-    memset(&tokens, 0, sizeof(tokens));
-
-    jsmn_parse(&parser, entry->json, entry->json_size, tokens, 2);
-    jsmntok_t *name_token = &tokens[1];
-
-    if (name_token->start < name_token->end && name_token->start > 0) {
-        entry->name = entry->json + name_token->start;
-        entry->name_len = name_token->end - name_token->start;
-        return 1;
-    }
-    return 0;
-}
-
-static int entry_lexical_comparator(const entry_t **a, const entry_t **b) {
-    size_t size_a = (*a)->json_size;
-    size_t size_b = (*b)->json_size;
-    size_t min_length = size_a < size_b ? size_a : size_b;
-
-    return strncmp((*a)->json, (*b)->json, min_length);
-}
-
-void hashmap_setup(struct hashmap *map) {
-    hashmap_init(map, (size_t(*)(const void *))hashmap_hash_entry,
-                 (int (*)(const void *, const void *))hashmap_compare_entry, 1000);
-    hashmap_set_key_alloc_funcs(map, NULL, (void (*)(void *))entry_free);
-}
-
-int process_buffer(file_t *file_info, buffer_t *source, struct hashmap *map) {
-    if (source->size < START_POSITION) {
-        // nothing to read
-        return 1;
-    }
-    uint32_t used;
-    memcpy(&used, source->buffer, sizeof(uint32_t));
-
-    if (used > source->size) {
-        save_exception(prom_eParsingError, "source file %s corrupted, used %u > file size %u", file_info->path, used,
-                       source->size);
-        return 0;
-    }
-
-    uint32_t pos = START_POSITION;
-    while (pos + sizeof(uint32_t) < used) {
-        uint32_t encoded_len;
-        memcpy(&encoded_len, source->buffer + pos, sizeof(uint32_t));
-        pos += sizeof(uint32_t);
-
-        uint32_t value_offset = encoded_len + padding_length(encoded_len);
-
-        if (pos + value_offset + sizeof(double) > used) {
-            save_exception(prom_eParsingError, "source file %s corrupted, used %u < stored data length %u",
-                           file_info->path, used, pos + value_offset + sizeof(double));
-            return 0;
-        }
-
-        entry_t *entry = entry_new(source, pos, encoded_len, file_info);
-        if (entry == NULL) {
-            save_exception(rb_eNoMemError, "Failed creating metrics entry");
-            return 0;
-        }
-
-        merge_or_store(map, entry);
-
-        pos += value_offset + sizeof(double);
-    }
-    return 1;
-}
-
-int sort_map_entries(const struct hashmap *map, entry_t ***sorted_entries) {
-    size_t num = hashmap_size(map);
-
-    entry_t **list = calloc(num, sizeof(entry_t *));
-
-    if (list == NULL) {
-        save_exception(rb_eNoMemError, "Couldn't allocate for %zu memory", num * sizeof(entry_t *));
-        return 0;
-    }
-
-    size_t cnt = 0;
-    struct hashmap_iter *iter;
-    for (iter = hashmap_iter(map); iter; iter = hashmap_iter_next(map, iter)) {
-        entry_t *entry = (entry_t *)entry_hashmap_iter_get_key(iter);
-        if (add_parsed_name(entry)) {
-            list[cnt] = entry;
-            cnt++;
-        }
-    }
-    if (cnt != num) {
-        save_exception(rb_eRuntimeError, "Processed entries %zu != map entries %zu", cnt, num);
-        free(list);
-        return 0;
-    }
-
-    qsort(list, cnt, sizeof(entry_t *), (compare_fn)&entry_lexical_comparator);
-    *sorted_entries = list;
-    return 1;
-}
-
-int is_pid_significant(const entry_t *e) {
-    ID mp = e->multiprocess_mode;
-    return e->type == sym_gauge && !(mp == sym_min || mp == sym_max || mp == sym_livesum);
-}

data/ext/fast_mmaped_file/file_parsing.h

@@ -1,27 +0,0 @@
-#ifndef FILE_PARSING_H
-#define FILE_PARSING_H
-#include <file_reading.h>
-#include <hashmap.h>
-#include <ruby.h>
-
-typedef struct {
-    char *json;
-    size_t json_size;
-    char *name;
-    size_t name_len;
-
-    ID multiprocess_mode;
-    ID type;
-    VALUE pid;
-
-    double value;
-} entry_t;
-
-void hashmap_setup(struct hashmap *map);
-
-int process_buffer(file_t *file_info, buffer_t *source, struct hashmap *map);
-int sort_map_entries(const struct hashmap *map, entry_t ***sorted_entries);
-
-int is_pid_significant(const entry_t *e);
-
-#endif

data/ext/fast_mmaped_file/file_reading.c

@@ -1,102 +0,0 @@
-#include "file_reading.h"
-
-#include <errno.h>
-#include <fcntl.h>
-
-#include "utils.h"
-
-static int file_open(file_t *source, const char *filepath) {
-    source->file = fopen(filepath, "r");
-    size_t filepath_len = strlen(filepath) + sizeof(char);
-    source->path = malloc(filepath_len);
-    memcpy(source->path, filepath, filepath_len);
-
-    if (source->file == NULL) {
-        save_exception(rb_eArgError, "Can't open %s, errno: %d", filepath, errno);
-
-        return 0;
-    }
-
-    struct stat sb;
-    if (fstat(fileno(source->file), &sb) != 0) {
-        fclose(source->file);
-        save_exception(rb_eIOError, "Can't stat file, errno: %d", errno);
-
-        return 0;
-    }
-    source->length = sb.st_size;
-
-    // go to start
-    if (fseek(source->file, 0L, SEEK_SET) != 0) {
-        fclose(source->file);
-        save_exception(rb_eIOError, "Can't fseek %zu, errno: %d", 0, errno);
-
-        return 0;
-    }
-
-    return 1;
-}
-
-int file_close(file_t *source) {
-    free(source->path);
-    if (fclose(source->file) != 0) {
-        save_exception(rb_eIOError, "Can't fclose file, errno: %d", 0, errno);
-        return 0;
-    }
-    source->file = 0;
-
-    return 1;
-}
-
-int file_open_from_params(file_t *source, VALUE params) {
-    if (RARRAY_LEN(params) != 4) {
-        save_exception(rb_eArgError, "wrong number of arguments %lu instead of 4", RARRAY_LEN(params));
-        return 0;
-    }
-
-    VALUE filepath = rb_ary_entry(params, 0);
-
-    source->multiprocess_mode = rb_sym2id(rb_ary_entry(params, 1));
-    source->type = rb_sym2id(rb_ary_entry(params, 2));
-    source->pid = rb_ary_entry(params, 3);
-
-    return file_open(source, StringValueCStr(filepath));
-}
-
-int read_from_file(const file_t *source, buffer_t *data) {
-    data->size = 0;
-    if (data->buffer == NULL) {
-        data->buffer = malloc(source->length);
-        if (data->buffer == NULL) {
-            save_exception(rb_eIOError, "Can't malloc %zu, errno: %d", source->length, errno);
-            return 0;
-        }
-
-        data->capacity = source->length;
-    } else if (data->capacity < source->length) {
-        data->buffer = realloc(data->buffer, source->length);
-        if (data->buffer == NULL) {
-            save_exception(rb_eIOError, "Can't realloc %zu, errno: %d", source->length, errno);
-            return 0;
-        }
-
-        data->capacity = source->length;
-    }
-
-    data->size = fread(data->buffer, sizeof(char), source->length, source->file);
-    if (data->size != source->length) {
-        save_exception(rb_eIOError, "Couldn't read whole file, read %zu, instead of %zu", data->size, source->length);
-        return 0;
-    }
-
-    return 1;
-}
-
-void buffer_dispose(buffer_t *buffer) {
-    if (buffer->buffer) {
-        free(buffer->buffer);
-    }
-    buffer->buffer = NULL;
-    buffer->size = 0;
-    buffer->capacity = 0;
-}

data/ext/fast_mmaped_file/file_reading.h

@@ -1,30 +0,0 @@
-#ifndef FILE_READING_H
-#define FILE_READING_H
-#include <ruby.h>
-
-typedef struct {
-    FILE *file;
-    size_t length;
-    char *path;
-
-    // Information processed from file path
-    ID multiprocess_mode;
-    ID type;
-    VALUE pid;
-} file_t;
-
-typedef struct {
-    char *buffer;
-    size_t size;
-    size_t capacity;
-} buffer_t;
-
-int file_close(file_t *file);
-
-int file_open_from_params(file_t *file, VALUE params);
-
-int read_from_file(const file_t *source, buffer_t *data);
-
-void buffer_dispose(buffer_t *buffer);
-
-#endif

data/ext/fast_mmaped_file/globals.h

@@ -1,14 +0,0 @@
-#ifndef GLOBALS_H
-#define GLOBALS_H
-#include <ruby.h>
-
-extern ID sym_min;
-extern ID sym_max;
-extern ID sym_livesum;
-extern ID sym_gauge;
-extern ID sym_pid;
-extern ID sym_samples;
-
-extern VALUE prom_eParsingError;
-
-#endif