v11.0.0

pkg/cloudapi/prometheus/compute_cpu_load.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeCPULoadRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Per-second CPU time consumed by Compute in percent, average over the time step specified
+func (p Prometheus) ComputeCPULoad(ctx context.Context, req ComputeCPULoadRequest) (*PrometheusData, error) {
+	res, err := p.ComputeCPULoadRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeCPULoadRaw(ctx context.Context, req ComputeCPULoadRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeCPUload"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_memory_available.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeMemoryAvailableRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Available Memory
+func (p Prometheus) ComputeMemoryAvailable(ctx context.Context, req ComputeMemoryAvailableRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryAvailableRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryAvailableRaw(ctx context.Context, req ComputeMemoryAvailableRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeMemoryAvailable"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_memory_unused.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeMemoryUnusedRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Unused Memory
+func (p Prometheus) ComputeMemoryUnused(ctx context.Context, req ComputeMemoryUnusedRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUnusedRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUnusedRaw(ctx context.Context, req ComputeMemoryUnusedRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeMemoryUnused"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_memory_usable.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeMemoryUsableRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Usable Memory
+func (p Prometheus) ComputeMemoryUsable(ctx context.Context, req ComputeMemoryUsableRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsableRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsableRaw(ctx context.Context, req ComputeMemoryUsableRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeMemoryUsable"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_memory_usage.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeMemoryUsageRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Memory Usage
+func (p Prometheus) ComputeMemoryUsage(ctx context.Context, req ComputeMemoryUsageRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsageRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsageRaw(ctx context.Context, req ComputeMemoryUsageRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeMemoryUsage"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_memory_used.go

@@ -0,0 +1,53 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeMemoryUsedRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+}
+
+// Used Memory
+func (p Prometheus) ComputeMemoryUsed(ctx context.Context, req ComputeMemoryUsedRequest) (*PrometheusData, error) {
+	res, err := p.ComputeMemoryUsedRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeMemoryUsedRaw(ctx context.Context, req ComputeMemoryUsedRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeMemoryUsed"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_read_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeReadBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Read Bytes
+func (p Prometheus) ComputeReadBytes(ctx context.Context, req ComputeReadBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReadBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReadBytesRaw(ctx context.Context, req ComputeReadBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeReadBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_read_requests.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeReadRequestsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Read Requests
+func (p Prometheus) ComputeReadRequests(ctx context.Context, req ComputeReadRequestsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReadRequestsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReadRequestsRaw(ctx context.Context, req ComputeReadRequestsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeReadRequests"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_receive_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeReceiveBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Receive Bytes
+func (p Prometheus) ComputeReceiveBytes(ctx context.Context, req ComputeReceiveBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReceiveBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReceiveBytesRaw(ctx context.Context, req ComputeReceiveBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeReceiveBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_receive_packets.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeReceivePacketsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Receive Packets
+func (p Prometheus) ComputeReceivePackets(ctx context.Context, req ComputeReceivePacketsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeReceivePacketsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeReceivePacketsRaw(ctx context.Context, req ComputeReceivePacketsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeReceivePackets"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_transmit_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeTransmitBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Transmit Bytes
+func (p Prometheus) ComputeTransmitBytes(ctx context.Context, req ComputeTransmitBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeTransmitBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeTransmitBytesRaw(ctx context.Context, req ComputeTransmitBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeTransmitBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_transmit_packets.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeTransmitPacketsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Transmit Packets
+func (p Prometheus) ComputeTransmitPackets(ctx context.Context, req ComputeTransmitPacketsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeTransmitPacketsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeTransmitPacketsRaw(ctx context.Context, req ComputeTransmitPacketsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeTransmitPackets"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_write_bytes.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeWriteBytesRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Write Bytes
+func (p Prometheus) ComputeWriteBytes(ctx context.Context, req ComputeWriteBytesRequest) (*PrometheusData, error) {
+	res, err := p.ComputeWriteBytesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeWriteBytesRaw(ctx context.Context, req ComputeWriteBytesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeWriteBytes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/compute_write_requests.go

@@ -0,0 +1,57 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+type ComputeWriteRequestsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Write Requests
+func (p Prometheus) ComputeWriteRequests(ctx context.Context, req ComputeWriteRequestsRequest) (*PrometheusData, error) {
+	res, err := p.ComputeWriteRequestsRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := PrometheusData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputeWriteRequestsRaw(ctx context.Context, req ComputeWriteRequestsRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computeWriteRequests"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/computes.go

@@ -0,0 +1,77 @@
+package prometheus
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/internal/validators"
+)
+
+const (
+	ComputeCPULoad         = "computeCPUload"
+	ComputeMemoryUsage     = "computeMemoryUsage"
+	ComputeMemoryUsable    = "computeMemoryUsable"
+	ComputeMemoryUnused    = "computeMemoryUnused"
+	ComputeMemoryUsed      = "computeMemoryUsed"
+	ComputeMemoryAvailable = "computeMemoryAvailable"
+	ComputeReadBytes       = "computeReadBytes"
+	ComputeReadRequests    = "computeReadRequests"
+	ComputeReceiveBytes    = "computeReceiveBytes"
+	ComputeTransmitBytes   = "computeTransmitBytes"
+	ComputeTransmitPackets = "computeTransmitPackets"
+	ComputeWriteBytes      = "computeWriteBytes"
+	ComputeWriteRequests   = "computeWriteRequests"
+)
+
+type ComputesRequest struct {
+	// List of compute IDs to fetch metrics for
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"required"`
+
+	// List of compute IDs to fetch metrics for
+	// Required: true
+	MetricIDs []string `url:"metricIds" json:"metricIds" validate:"required"`
+
+	// Time to loads of statistic in seconds
+	// Required: false
+	ForLast uint64 `url:"forLast,omitempty" json:"forLast,omitempty"`
+
+	// The reading interval in seconds
+	// Required: false
+	Step uint64 `url:"step,omitempty" json:"step,omitempty"`
+
+	// Number of zeros after the decimal point
+	// Required: false
+	DecimalPlaces uint64 `url:"decimalPlaces,omitempty" json:"decimalPlaces,omitempty"`
+}
+
+// Get multiple metrics for multiple compute instances
+func (p Prometheus) Computes(ctx context.Context, req ComputesRequest) (*ComputesData, error) {
+	res, err := p.ComputesRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := ComputesData{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (p Prometheus) ComputesRaw(ctx context.Context, req ComputesRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/prometheus/computes"
+
+	res, err := p.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/prometheus/models.go

@@ -0,0 +1,40 @@
+package prometheus
+
+// PrometheusData represents an array of data points
+type PrometheusData []PrometheusPoint
+
+// PrometheusPoint represents a single data point
+type PrometheusPoint struct {
+	// Value of the metric at a specific point in time
+	Value float64 `json:"value"`
+
+	// Timestamp the Unix timestamp.
+	Timestamp uint64 `json:"timestamp"`
+}
+
+// ComputesData represents an array of data points for computes
+type ComputesData []ItemCompute
+
+// ItemCompute represents a single data of compute
+type ItemCompute struct {
+	// Compute ID
+	ComputeID uint64 `json:"computeId"`
+
+	// Array of metrics
+	Metrics []ItemMetric `json:"metrics"`
+
+	// Error
+	Error string `json:"error"`
+}
+
+// ItemMetric represents a single data point of metric
+type ItemMetric struct {
+	// Metric ID
+	MetricID string `json:"metricId"`
+
+	// Data represents an array of data points
+	Data PrometheusData `json:"data"`
+
+	// Error
+	Error string `json:"error"`
+}

pkg/cloudapi/prometheus/prometheus.go

@@ -0,0 +1,15 @@
+package prometheus
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v11/interfaces"
+)
+
+type Prometheus struct {
+	client interfaces.Caller
+}
+
+func New(client interfaces.Caller) *Prometheus {
+	return &Prometheus{
+		client: client,
+	}
+}