iot

application/src/main/data/upgrade/3.1.1/schema_update_after.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+DROP PROCEDURE IF EXISTS update_tenant_profiles;
+DROP PROCEDURE IF EXISTS update_device_profiles;
+
+ALTER TABLE tenant ALTER COLUMN tenant_profile_id SET NOT NULL;
+ALTER TABLE tenant DROP CONSTRAINT IF EXISTS fk_tenant_profile;
+ALTER TABLE tenant ADD CONSTRAINT fk_tenant_profile FOREIGN KEY (tenant_profile_id) REFERENCES tenant_profile(id);
+ALTER TABLE tenant DROP COLUMN IF EXISTS isolated_tb_core;
+ALTER TABLE tenant DROP COLUMN IF EXISTS isolated_tb_rule_engine;
+
+ALTER TABLE device ALTER COLUMN device_profile_id SET NOT NULL;
+ALTER TABLE device DROP CONSTRAINT IF EXISTS fk_device_profile;
+ALTER TABLE device ADD CONSTRAINT fk_device_profile FOREIGN KEY (device_profile_id) REFERENCES device_profile(id);

application/src/main/data/upgrade/3.1.1/schema_update_before.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS oauth2_client_registration_info (
+    id uuid NOT NULL CONSTRAINT oauth2_client_registration_info_pkey PRIMARY KEY,
+    enabled boolean,
+    created_time bigint NOT NULL,
+    additional_info varchar,
+    client_id varchar(255),
+    client_secret varchar(255),
+    authorization_uri varchar(255),
+    token_uri varchar(255),
+    scope varchar(255),
+    user_info_uri varchar(255),
+    user_name_attribute_name varchar(255),
+    jwk_set_uri varchar(255),
+    client_authentication_method varchar(255),
+    login_button_label varchar(255),
+    login_button_icon varchar(255),
+    allow_user_creation boolean,
+    activate_user boolean,
+    type varchar(31),
+    basic_email_attribute_key varchar(31),
+    basic_first_name_attribute_key varchar(31),
+    basic_last_name_attribute_key varchar(31),
+    basic_tenant_name_strategy varchar(31),
+    basic_tenant_name_pattern varchar(255),
+    basic_customer_name_pattern varchar(255),
+    basic_default_dashboard_name varchar(255),
+    basic_always_full_screen boolean,
+    custom_url varchar(255),
+    custom_username varchar(255),
+    custom_password varchar(255),
+    custom_send_token boolean
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_client_registration (
+    id uuid NOT NULL CONSTRAINT oauth2_client_registration_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    domain_name varchar(255),
+    domain_scheme varchar(31),
+    client_registration_info_id uuid
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_client_registration_template (
+    id uuid NOT NULL CONSTRAINT oauth2_client_registration_template_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    additional_info varchar,
+    provider_id varchar(255),
+    authorization_uri varchar(255),
+    token_uri varchar(255),
+    scope varchar(255),
+    user_info_uri varchar(255),
+    user_name_attribute_name varchar(255),
+    jwk_set_uri varchar(255),
+    client_authentication_method varchar(255),
+    type varchar(31),
+    basic_email_attribute_key varchar(31),
+    basic_first_name_attribute_key varchar(31),
+    basic_last_name_attribute_key varchar(31),
+    basic_tenant_name_strategy varchar(31),
+    basic_tenant_name_pattern varchar(255),
+    basic_customer_name_pattern varchar(255),
+    basic_default_dashboard_name varchar(255),
+    basic_always_full_screen boolean,
+    comment varchar,
+    login_button_icon varchar(255),
+    login_button_label varchar(255),
+    help_link varchar(255),
+    CONSTRAINT oauth2_template_provider_id_unq_key UNIQUE (provider_id)
+);
+
+CREATE TABLE IF NOT EXISTS device_profile (
+    id uuid NOT NULL CONSTRAINT device_profile_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    name varchar(255),
+    type varchar(255),
+    transport_type varchar(255),
+    provision_type varchar(255),
+    profile_data jsonb,
+    description varchar,
+    search_text varchar(255),
+    is_default boolean,
+    tenant_id uuid,
+    default_rule_chain_id uuid,
+    default_queue_name varchar(255),
+    provision_device_key varchar,
+    CONSTRAINT device_profile_name_unq_key UNIQUE (tenant_id, name),
+    CONSTRAINT device_provision_key_unq_key UNIQUE (provision_device_key),
+    CONSTRAINT fk_default_rule_chain_device_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id)
+);
+
+CREATE TABLE IF NOT EXISTS tenant_profile (
+    id uuid NOT NULL CONSTRAINT tenant_profile_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    name varchar(255),
+    profile_data jsonb,
+    description varchar,
+    search_text varchar(255),
+    is_default boolean,
+    isolated_tb_core boolean,
+    isolated_tb_rule_engine boolean,
+    CONSTRAINT tenant_profile_name_unq_key UNIQUE (name)
+);
+
+CREATE OR REPLACE PROCEDURE update_tenant_profiles()
+    LANGUAGE plpgsql AS
+$$
+BEGIN
+    UPDATE tenant as t SET tenant_profile_id = p.id
+    FROM
+        (SELECT id from tenant_profile WHERE isolated_tb_core = false AND isolated_tb_rule_engine = false) as p
+    WHERE t.tenant_profile_id IS NULL AND t.isolated_tb_core = false AND t.isolated_tb_rule_engine = false;
+
+    UPDATE tenant as t SET tenant_profile_id = p.id
+    FROM
+        (SELECT id from tenant_profile WHERE isolated_tb_core = true AND isolated_tb_rule_engine = false) as p
+    WHERE t.tenant_profile_id IS NULL AND t.isolated_tb_core = true AND t.isolated_tb_rule_engine = false;
+
+    UPDATE tenant as t SET tenant_profile_id = p.id
+    FROM
+        (SELECT id from tenant_profile WHERE isolated_tb_core = false AND isolated_tb_rule_engine = true) as p
+    WHERE t.tenant_profile_id IS NULL AND t.isolated_tb_core = false AND t.isolated_tb_rule_engine = true;
+
+    UPDATE tenant as t SET tenant_profile_id = p.id
+    FROM
+        (SELECT id from tenant_profile WHERE isolated_tb_core = true AND isolated_tb_rule_engine = true) as p
+    WHERE t.tenant_profile_id IS NULL AND t.isolated_tb_core = true AND t.isolated_tb_rule_engine = true;
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE update_device_profiles()
+    LANGUAGE plpgsql AS
+$$
+BEGIN
+    UPDATE device as d SET device_profile_id = p.id, device_data = '{"configuration":{"type":"DEFAULT"}, "transportConfiguration":{"type":"DEFAULT"}}'
+        FROM
+           (SELECT id, tenant_id, name from device_profile) as p
+                WHERE d.device_profile_id IS NULL AND p.tenant_id = d.tenant_id AND d.type = p.name;
+END;
+$$;

application/src/main/data/upgrade/3.2.1/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+ALTER TABLE widget_type
+    ADD COLUMN IF NOT EXISTS image varchar (1000000),
+    ADD COLUMN IF NOT EXISTS description varchar (255);
+
+ALTER TABLE widgets_bundle
+    ADD COLUMN IF NOT EXISTS image varchar (1000000),
+    ADD COLUMN IF NOT EXISTS description varchar (255);

application/src/main/data/upgrade/3.2.1/schema_update_ttl.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE OR REPLACE PROCEDURE cleanup_timeseries_by_ttl(IN null_uuid uuid,
+                                                      IN system_ttl bigint, INOUT deleted bigint)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+tenant_cursor CURSOR FOR select tenant.id as tenant_id
+                         from tenant;
+    tenant_id_record     uuid;
+    customer_id_record   uuid;
+    tenant_ttl           bigint;
+    customer_ttl         bigint;
+    deleted_for_entities bigint;
+    tenant_ttl_ts        bigint;
+    customer_ttl_ts      bigint;
+BEGIN
+OPEN tenant_cursor;
+FETCH tenant_cursor INTO tenant_id_record;
+WHILE FOUND
+        LOOP
+            EXECUTE format(
+                    'select attribute_kv.long_v from attribute_kv where attribute_kv.entity_id = %L and attribute_kv.attribute_key = %L',
+                    tenant_id_record, 'TTL') INTO tenant_ttl;
+            if tenant_ttl IS NULL THEN
+                tenant_ttl := system_ttl;
+END IF;
+            IF tenant_ttl > 0 THEN
+                tenant_ttl_ts := (EXTRACT(EPOCH FROM current_timestamp) * 1000 - tenant_ttl::bigint * 1000)::bigint;
+                deleted_for_entities := delete_device_records_from_ts_kv(tenant_id_record, null_uuid, tenant_ttl_ts);
+                deleted := deleted + deleted_for_entities;
+                RAISE NOTICE '% telemetry removed for devices where tenant_id = %', deleted_for_entities, tenant_id_record;
+                deleted_for_entities := delete_asset_records_from_ts_kv(tenant_id_record, null_uuid, tenant_ttl_ts);
+                deleted := deleted + deleted_for_entities;
+                RAISE NOTICE '% telemetry removed for assets where tenant_id = %', deleted_for_entities, tenant_id_record;
+END IF;
+FOR customer_id_record IN
+SELECT customer.id AS customer_id FROM customer WHERE customer.tenant_id = tenant_id_record
+    LOOP
+                    EXECUTE format(
+                            'select attribute_kv.long_v from attribute_kv where attribute_kv.entity_id = %L and attribute_kv.attribute_key = %L',
+                            customer_id_record, 'TTL') INTO customer_ttl;
+IF customer_ttl IS NULL THEN
+                        customer_ttl_ts := tenant_ttl_ts;
+ELSE
+                        IF customer_ttl > 0 THEN
+                            customer_ttl_ts :=
+                                    (EXTRACT(EPOCH FROM current_timestamp) * 1000 -
+                                     customer_ttl::bigint * 1000)::bigint;
+END IF;
+END IF;
+                    IF customer_ttl_ts IS NOT NULL AND customer_ttl_ts > 0 THEN
+                        deleted_for_entities :=
+                                delete_customer_records_from_ts_kv(tenant_id_record, customer_id_record,
+                                                                   customer_ttl_ts);
+                        deleted := deleted + deleted_for_entities;
+                        RAISE NOTICE '% telemetry removed for customer with id = % where tenant_id = %', deleted_for_entities, customer_id_record, tenant_id_record;
+                        deleted_for_entities :=
+                                delete_device_records_from_ts_kv(tenant_id_record, customer_id_record,
+                                                                 customer_ttl_ts);
+                        deleted := deleted + deleted_for_entities;
+                        RAISE NOTICE '% telemetry removed for devices where tenant_id = % and customer_id = %', deleted_for_entities, tenant_id_record, customer_id_record;
+                        deleted_for_entities := delete_asset_records_from_ts_kv(tenant_id_record,
+                                                                                customer_id_record,
+                                                                                customer_ttl_ts);
+                        deleted := deleted + deleted_for_entities;
+                        RAISE NOTICE '% telemetry removed for assets where tenant_id = % and customer_id = %', deleted_for_entities, tenant_id_record, customer_id_record;
+END IF;
+END LOOP;
+FETCH tenant_cursor INTO tenant_id_record;
+END LOOP;
+END
+$$;

application/src/main/data/upgrade/3.2.2/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS edge (
+    id uuid NOT NULL CONSTRAINT edge_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    additional_info varchar,
+    customer_id uuid,
+    root_rule_chain_id uuid,
+    type varchar(255),
+    name varchar(255),
+    label varchar(255),
+    routing_key varchar(255),
+    secret varchar(255),
+    edge_license_key varchar(30),
+    cloud_endpoint varchar(255),
+    search_text varchar(255),
+    tenant_id uuid,
+    CONSTRAINT edge_name_unq_key UNIQUE (tenant_id, name),
+    CONSTRAINT edge_routing_key_unq_key UNIQUE (routing_key)
+    );
+
+CREATE TABLE IF NOT EXISTS edge_event (
+    id uuid NOT NULL CONSTRAINT edge_event_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    edge_id uuid,
+    edge_event_type varchar(255),
+    edge_event_uid varchar(255),
+    entity_id uuid,
+    edge_event_action varchar(255),
+    body varchar(10000000),
+    tenant_id uuid,
+    ts bigint NOT NULL
+    );
+
+CREATE TABLE IF NOT EXISTS resource (
+    id uuid NOT NULL CONSTRAINT resource_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    title varchar(255) NOT NULL,
+    resource_type varchar(32) NOT NULL,
+    resource_key varchar(255) NOT NULL,
+    search_text varchar(255),
+    file_name varchar(255) NOT NULL,
+    data varchar,
+    CONSTRAINT resource_unq_key UNIQUE (tenant_id, resource_type, resource_key)
+);
+
+CREATE TABLE IF NOT EXISTS ota_package (
+    id uuid NOT NULL CONSTRAINT ota_package_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    device_profile_id uuid,
+    type varchar(32) NOT NULL,
+    title varchar(255) NOT NULL,
+    version varchar(255) NOT NULL,
+    tag varchar(255),
+    url varchar(255),
+    file_name varchar(255),
+    content_type varchar(255),
+    checksum_algorithm varchar(32),
+    checksum varchar(1020),
+    data oid,
+    data_size bigint,
+    additional_info varchar,
+    search_text varchar(255),
+    CONSTRAINT ota_package_tenant_title_version_unq_key UNIQUE (tenant_id, title, version)
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_params (
+    id uuid NOT NULL CONSTRAINT oauth2_params_pkey PRIMARY KEY,
+    enabled boolean,
+    tenant_id uuid,
+    created_time bigint NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_registration (
+    id uuid NOT NULL CONSTRAINT oauth2_registration_pkey PRIMARY KEY,
+    oauth2_params_id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    additional_info varchar,
+    client_id varchar(255),
+    client_secret varchar(2048),
+    authorization_uri varchar(255),
+    token_uri varchar(255),
+    scope varchar(255),
+    platforms varchar(255),
+    user_info_uri varchar(255),
+    user_name_attribute_name varchar(255),
+    jwk_set_uri varchar(255),
+    client_authentication_method varchar(255),
+    login_button_label varchar(255),
+    login_button_icon varchar(255),
+    allow_user_creation boolean,
+    activate_user boolean,
+    type varchar(31),
+    basic_email_attribute_key varchar(31),
+    basic_first_name_attribute_key varchar(31),
+    basic_last_name_attribute_key varchar(31),
+    basic_tenant_name_strategy varchar(31),
+    basic_tenant_name_pattern varchar(255),
+    basic_customer_name_pattern varchar(255),
+    basic_default_dashboard_name varchar(255),
+    basic_always_full_screen boolean,
+    custom_url varchar(255),
+    custom_username varchar(255),
+    custom_password varchar(255),
+    custom_send_token boolean,
+    CONSTRAINT fk_registration_oauth2_params FOREIGN KEY (oauth2_params_id) REFERENCES oauth2_params(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_domain (
+    id uuid NOT NULL CONSTRAINT oauth2_domain_pkey PRIMARY KEY,
+    oauth2_params_id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    domain_name varchar(255),
+    domain_scheme varchar(31),
+    CONSTRAINT fk_domain_oauth2_params FOREIGN KEY (oauth2_params_id) REFERENCES oauth2_params(id) ON DELETE CASCADE,
+    CONSTRAINT oauth2_domain_unq_key UNIQUE (oauth2_params_id, domain_name, domain_scheme)
+);
+
+CREATE TABLE IF NOT EXISTS oauth2_mobile (
+    id uuid NOT NULL CONSTRAINT oauth2_mobile_pkey PRIMARY KEY,
+    oauth2_params_id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    pkg_name varchar(255),
+    app_secret varchar(2048),
+    CONSTRAINT fk_mobile_oauth2_params FOREIGN KEY (oauth2_params_id) REFERENCES oauth2_params(id) ON DELETE CASCADE,
+    CONSTRAINT oauth2_mobile_unq_key UNIQUE (oauth2_params_id, pkg_name)
+);
+
+ALTER TABLE dashboard
+    ADD COLUMN IF NOT EXISTS image varchar(1000000),
+    ADD COLUMN IF NOT EXISTS mobile_hide boolean DEFAULT false,
+    ADD COLUMN IF NOT EXISTS mobile_order int;
+
+ALTER TABLE device_profile
+    ADD COLUMN IF NOT EXISTS image varchar(1000000),
+    ADD COLUMN IF NOT EXISTS firmware_id uuid,
+    ADD COLUMN IF NOT EXISTS software_id uuid,
+    ADD COLUMN IF NOT EXISTS default_dashboard_id uuid;
+
+ALTER TABLE device
+    ADD COLUMN IF NOT EXISTS firmware_id uuid,
+    ADD COLUMN IF NOT EXISTS software_id uuid;
+
+ALTER TABLE alarm
+    ADD COLUMN IF NOT EXISTS customer_id uuid;
+
+DELETE FROM relation WHERE from_type = 'TENANT' AND relation_type_group = 'RULE_CHAIN';
+
+DO $$
+    BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_firmware_device_profile') THEN
+            ALTER TABLE device_profile
+                ADD CONSTRAINT fk_firmware_device_profile
+                    FOREIGN KEY (firmware_id) REFERENCES ota_package(id);
+        END IF;
+
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_software_device_profile') THEN
+            ALTER TABLE device_profile
+                ADD CONSTRAINT fk_software_device_profile
+                    FOREIGN KEY (firmware_id) REFERENCES ota_package(id);
+        END IF;
+
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_default_dashboard_device_profile') THEN
+            ALTER TABLE device_profile
+                ADD CONSTRAINT fk_default_dashboard_device_profile
+                    FOREIGN KEY (default_dashboard_id) REFERENCES dashboard(id);
+        END IF;
+
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_firmware_device') THEN
+            ALTER TABLE device
+                ADD CONSTRAINT fk_firmware_device
+                    FOREIGN KEY (firmware_id) REFERENCES ota_package(id);
+        END IF;
+
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_software_device') THEN
+            ALTER TABLE device
+                ADD CONSTRAINT fk_software_device
+                    FOREIGN KEY (firmware_id) REFERENCES ota_package(id);
+        END IF;
+    END;
+$$;
+
+
+ALTER TABLE api_usage_state
+    ADD COLUMN IF NOT EXISTS alarm_exec VARCHAR(32);
+UPDATE api_usage_state SET alarm_exec = 'ENABLED' WHERE alarm_exec IS NULL;
+
+CREATE TABLE IF NOT EXISTS rpc (
+    id uuid NOT NULL CONSTRAINT rpc_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    device_id uuid NOT NULL,
+    expiration_time bigint NOT NULL,
+    request varchar(10000000) NOT NULL,
+    response varchar(10000000),
+    additional_info varchar(10000000),
+    status varchar(255) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_rpc_tenant_id_device_id ON rpc(tenant_id, device_id);

application/src/main/data/upgrade/3.2.2/schema_update_event.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+-- PROCEDURE: public.cleanup_events_by_ttl(bigint, bigint, bigint)
+
+DROP PROCEDURE IF EXISTS public.cleanup_events_by_ttl(bigint, bigint, bigint);
+
+CREATE OR REPLACE PROCEDURE public.cleanup_events_by_ttl(
+	ttl bigint,
+	debug_ttl bigint,
+	INOUT deleted bigint)
+LANGUAGE 'plpgsql'
+AS $BODY$
+DECLARE
+    ttl_ts bigint;
+    debug_ttl_ts bigint;
+    ttl_deleted_count bigint DEFAULT 0;
+    debug_ttl_deleted_count bigint DEFAULT 0;
+BEGIN
+    IF ttl > 0 THEN
+        ttl_ts := (EXTRACT(EPOCH FROM current_timestamp) * 1000 - ttl::bigint * 1000)::bigint;
+
+        DELETE FROM event
+		  WHERE ts < ttl_ts
+		    AND NOT event_type IN ('DEBUG_RULE_NODE', 'DEBUG_RULE_CHAIN', 'DEBUG_CONVERTER', 'DEBUG_INTEGRATION');
+
+		GET DIAGNOSTICS ttl_deleted_count = ROW_COUNT;
+    END IF;
+
+    IF debug_ttl > 0 THEN
+        debug_ttl_ts := (EXTRACT(EPOCH FROM current_timestamp) * 1000 - debug_ttl::bigint * 1000)::bigint;
+
+		DELETE FROM event
+		  WHERE ts < debug_ttl_ts
+		    AND     event_type IN ('DEBUG_RULE_NODE', 'DEBUG_RULE_CHAIN', 'DEBUG_CONVERTER', 'DEBUG_INTEGRATION');
+
+		GET DIAGNOSTICS debug_ttl_deleted_count = ROW_COUNT;
+    END IF;
+
+    RAISE NOTICE 'Events removed by ttl: %', ttl_deleted_count;
+    RAISE NOTICE 'Debug Events removed by ttl: %', debug_ttl_deleted_count;
+    deleted := ttl_deleted_count + debug_ttl_deleted_count;
+END
+$BODY$;
+
+
+-- Index: idx_event_ts
+
+DROP INDEX IF EXISTS public.idx_event_ts;
+
+-- Hint: add CONCURRENTLY to CREATE INDEX query in case of more then 1 million records or during live update
+-- CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_event_ts
+CREATE INDEX IF NOT EXISTS idx_event_ts
+    ON public.event
+    (ts DESC NULLS LAST)
+    WITH (FILLFACTOR=95);
+
+COMMENT ON INDEX public.idx_event_ts
+    IS 'This index helps to delete events by TTL using timestamp';
+
+
+-- Index: idx_event_tenant_entity_type_entity_event_type_created_time_des
+
+DROP INDEX IF EXISTS public.idx_event_tenant_entity_type_entity_event_type_created_time_des;
+
+-- CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_event_tenant_entity_type_entity_event_type_created_time_des
+CREATE INDEX IF NOT EXISTS idx_event_tenant_entity_type_entity_event_type_created_time_des
+    ON public.event
+    (tenant_id ASC, entity_type ASC, entity_id ASC, event_type ASC, created_time DESC NULLS LAST)
+    WITH (FILLFACTOR=95);
+
+COMMENT ON INDEX public.idx_event_tenant_entity_type_entity_event_type_created_time_des
+    IS 'This index helps to open latest events on UI fast';
+
+-- Index: idx_event_type_entity_id
+-- Description: replaced with more suitable idx_event_tenant_entity_type_entity_event_type_created_time_des
+DROP INDEX IF EXISTS public.idx_event_type_entity_id;
\ No newline at end of file

application/src/main/data/upgrade/3.2.2/schema_update_ttl.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE OR REPLACE PROCEDURE cleanup_edge_events_by_ttl(IN ttl bigint, INOUT deleted bigint)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    ttl_ts bigint;
+    ttl_deleted_count bigint DEFAULT 0;
+BEGIN
+    IF ttl > 0 THEN
+        ttl_ts := (EXTRACT(EPOCH FROM current_timestamp) * 1000 - ttl::bigint * 1000)::bigint;
+        EXECUTE format(
+                'WITH deleted AS (DELETE FROM edge_event WHERE ts < %L::bigint RETURNING *) SELECT count(*) FROM deleted', ttl_ts) into ttl_deleted_count;
+    END IF;
+    RAISE NOTICE 'Edge events removed by ttl: %', ttl_deleted_count;
+    deleted := ttl_deleted_count;
+END
+$$;

application/src/main/data/upgrade/3.3.2/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS entity_alarm (
+    tenant_id uuid NOT NULL,
+    entity_type varchar(32),
+    entity_id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    alarm_type varchar(255) NOT NULL,
+    customer_id uuid,
+    alarm_id uuid,
+    CONSTRAINT entity_alarm_pkey PRIMARY KEY (entity_id, alarm_id),
+    CONSTRAINT fk_entity_alarm_id FOREIGN KEY (alarm_id) REFERENCES alarm(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_alarm_tenant_status_created_time ON alarm(tenant_id, status, created_time DESC);
+CREATE INDEX IF NOT EXISTS idx_entity_alarm_created_time ON entity_alarm(tenant_id, entity_id, created_time DESC);
+CREATE INDEX IF NOT EXISTS idx_entity_alarm_alarm_id ON entity_alarm(alarm_id);
+
+INSERT INTO entity_alarm(tenant_id, entity_type, entity_id, created_time, alarm_type, customer_id, alarm_id)
+SELECT tenant_id,
+       CASE
+           WHEN originator_type = 0 THEN 'TENANT'
+           WHEN originator_type = 1 THEN 'CUSTOMER'
+           WHEN originator_type = 2 THEN 'USER'
+           WHEN originator_type = 3 THEN 'DASHBOARD'
+           WHEN originator_type = 4 THEN 'ASSET'
+           WHEN originator_type = 5 THEN 'DEVICE'
+           WHEN originator_type = 6 THEN 'ALARM'
+           WHEN originator_type = 7 THEN 'RULE_CHAIN'
+           WHEN originator_type = 8 THEN 'RULE_NODE'
+           WHEN originator_type = 9 THEN 'ENTITY_VIEW'
+           WHEN originator_type = 10 THEN 'WIDGETS_BUNDLE'
+           WHEN originator_type = 11 THEN 'WIDGET_TYPE'
+           WHEN originator_type = 12 THEN 'TENANT_PROFILE'
+           WHEN originator_type = 13 THEN 'DEVICE_PROFILE'
+           WHEN originator_type = 14 THEN 'API_USAGE_STATE'
+           WHEN originator_type = 15 THEN 'TB_RESOURCE'
+           WHEN originator_type = 16 THEN 'OTA_PACKAGE'
+           WHEN originator_type = 17 THEN 'EDGE'
+           WHEN originator_type = 18 THEN 'RPC'
+           else 'UNKNOWN'
+           END,
+       originator_id,
+       created_time,
+       type,
+       customer_id,
+       id
+FROM alarm
+ON CONFLICT DO NOTHING;
+
+INSERT INTO entity_alarm(tenant_id, entity_type, entity_id, created_time, alarm_type, customer_id, alarm_id)
+SELECT a.tenant_id, r.from_type, r.from_id, created_time, type, customer_id, id
+FROM alarm a
+         INNER JOIN relation r ON r.relation_type_group = 'ALARM' and r.relation_type = 'ANY' and a.id = r.to_id
+ON CONFLICT DO NOTHING;
+
+DELETE FROM relation r WHERE r.relation_type_group = 'ALARM';
\ No newline at end of file

application/src/main/data/upgrade/3.3.2/schema_update_lwm2m_bootstrap.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+
+CREATE OR REPLACE PROCEDURE update_profile_bootstrap()
+  LANGUAGE plpgsql AS
+$$
+
+BEGIN
+
+  UPDATE device_profile
+  SET profile_data = jsonb_set(
+    profile_data,
+    '{transportConfiguration}',
+    get_bootstrap(
+      profile_data::jsonb #> '{transportConfiguration}',
+      subquery.publickey_bs,
+      subquery.publickey_lw,
+      profile_data::json #>> '{transportConfiguration, bootstrap, bootstrapServer, securityMode}',
+      profile_data::json #>> '{transportConfiguration, bootstrap, lwm2mServer, securityMode}'),
+    true)
+  FROM (
+         SELECT id,
+                encode(
+                  decode(profile_data::json #> '{transportConfiguration,bootstrap,bootstrapServer}' ->>
+                         'serverPublicKey', 'hex')::bytea, 'base64') AS publickey_bs,
+                encode(
+                  decode(profile_data::json #> '{transportConfiguration,bootstrap,lwm2mServer}' ->>
+                         'serverPublicKey', 'hex')::bytea, 'base64') AS publickey_lw
+         FROM device_profile
+         WHERE transport_type = 'LWM2M'
+       ) AS subquery
+  WHERE device_profile.id = subquery.id
+    AND subquery.publickey_bs IS NOT NULL
+    AND subquery.publickey_lw IS NOT NULL;
+
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_bootstrap(transport_configuration_in jsonb, publickey_bs text,
+                                         publickey_lw text, security_mode_bs text,
+                                         security_mode_lw text) RETURNS jsonb AS
+$$
+
+DECLARE
+  bootstrap_new jsonb;
+  bootstrap_in  jsonb;
+
+BEGIN
+
+  IF security_mode_lw IS NULL THEN
+    security_mode_lw := 'NO_SEC';
+  END IF;
+
+  IF security_mode_bs IS NULL THEN
+    security_mode_bs := 'NO_SEC';
+  END IF;
+
+  bootstrap_in := transport_configuration_in::jsonb #> '{bootstrap}';
+  bootstrap_new := json_build_array(
+    json_build_object('shortServerId', bootstrap_in::json #> '{bootstrapServer}' -> 'serverId',
+                      'securityMode', security_mode_bs,
+                      'binding', bootstrap_in::json #> '{servers}' ->> 'binding',
+                      'lifetime', bootstrap_in::json #> '{servers}' -> 'lifetime',
+                      'notifIfDisabled', bootstrap_in::json #> '{servers}' -> 'notifIfDisabled',
+                      'defaultMinPeriod', bootstrap_in::json #> '{servers}' -> 'defaultMinPeriod',
+                      'host', bootstrap_in::json #> '{bootstrapServer}' ->> 'host',
+                      'port', bootstrap_in::json #> '{bootstrapServer}' -> 'port',
+                      'serverPublicKey', publickey_bs,
+                      'bootstrapServerIs', true,
+                      'clientHoldOffTime', bootstrap_in::json #> '{bootstrapServer}' -> 'clientHoldOffTime',
+                      'bootstrapServerAccountTimeout',
+                      bootstrap_in::json #> '{bootstrapServer}' -> 'bootstrapServerAccountTimeout'
+      ),
+    json_build_object('shortServerId', bootstrap_in::json #> '{lwm2mServer}' -> 'serverId',
+                      'securityMode', security_mode_lw,
+                      'binding', bootstrap_in::json #> '{servers}' ->> 'binding',
+                      'lifetime', bootstrap_in::json #> '{servers}' -> 'lifetime',
+                      'notifIfDisabled', bootstrap_in::json #> '{servers}' -> 'notifIfDisabled',
+                      'defaultMinPeriod', bootstrap_in::json #> '{servers}' -> 'defaultMinPeriod',
+                      'host', bootstrap_in::json #> '{lwm2mServer}' ->> 'host',
+                      'port', bootstrap_in::json #> '{lwm2mServer}' -> 'port',
+                      'serverPublicKey', publickey_lw,
+                      'bootstrapServerIs', false,
+                      'clientHoldOffTime', bootstrap_in::json #> '{lwm2mServer}' -> 'clientHoldOffTime',
+                      'bootstrapServerAccountTimeout',
+                      bootstrap_in::json #> '{lwm2mServer}' -> 'bootstrapServerAccountTimeout'
+      )
+    );
+  RETURN jsonb_set(
+           transport_configuration_in,
+           '{bootstrap}',
+           bootstrap_new,
+           true) || '{"bootstrapServerUpdateEnable": true}';
+
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE PROCEDURE update_device_credentials_to_base64_and_bootstrap()
+  LANGUAGE plpgsql AS
+$$
+
+BEGIN
+
+  UPDATE device_credentials
+  SET credentials_value = get_device_and_bootstrap(credentials_value::text)
+  WHERE credentials_type = 'LWM2M_CREDENTIALS';
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION get_device_and_bootstrap(IN credentials_value text, OUT credentials_value_new text)
+  LANGUAGE plpgsql AS
+$$
+DECLARE
+  client_secret_key                    text;
+  client_public_key_or_id              text;
+  client_key_value_object              jsonb;
+  client_bootstrap_server_value_object jsonb;
+  client_bootstrap_server_object       jsonb;
+  client_bootstrap_object              jsonb;
+
+BEGIN
+  credentials_value_new := credentials_value;
+  IF credentials_value::jsonb #> '{client}' ->> 'securityConfigClientMode' = 'RPK' AND
+     NULLIF((credentials_value::jsonb #> '{client}' ->> 'key' ~ '^[0-9a-fA-F]+$')::text, 'false') = 'true' THEN
+    client_public_key_or_id := encode(decode(credentials_value::jsonb #> '{client}' ->> 'key', 'hex')::bytea, 'base64');
+    client_key_value_object := json_build_object(
+      'endpoint', credentials_value::jsonb #> '{client}' ->> 'endpoint',
+      'securityConfigClientMode', credentials_value::jsonb #> '{client}' ->> 'securityConfigClientMode',
+      'key', client_public_key_or_id);
+    credentials_value_new :=
+        credentials_value_new::jsonb || json_build_object('client', client_key_value_object)::jsonb;
+  END IF;
+  IF credentials_value::jsonb #> '{client}' ->> 'securityConfigClientMode' = 'X509' AND
+     NULLIF((credentials_value::jsonb #> '{client}' ->> 'cert' ~ '^[0-9a-fA-F]+$')::text, 'false') = 'true' THEN
+    client_public_key_or_id :=
+      encode(decode(credentials_value::jsonb #> '{client}' ->> 'cert', 'hex')::bytea, 'base64');
+    client_key_value_object := json_build_object(
+      'endpoint', credentials_value::jsonb #> '{client}' ->> 'endpoint',
+      'securityConfigClientMode', credentials_value::jsonb #> '{client}' ->> 'securityConfigClientMode',
+      'cert', client_public_key_or_id);
+    credentials_value_new :=
+        credentials_value_new::jsonb || json_build_object('client', client_key_value_object)::jsonb;
+  END IF;
+
+  IF credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'securityMode' = 'RPK' OR
+     credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'securityMode' = 'X509' THEN
+    IF NULLIF((credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'clientSecretKey' ~ '^[0-9a-fA-F]+$')::text,
+              'false') = 'true' AND
+       NULLIF(
+         (credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'clientPublicKeyOrId' ~ '^[0-9a-fA-F]+$')::text,
+         'false') = 'true' THEN
+      client_secret_key :=
+        encode(decode(credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'clientSecretKey', 'hex')::bytea,
+               'base64');
+      client_public_key_or_id := encode(
+        decode(credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'clientPublicKeyOrId', 'hex')::bytea,
+        'base64');
+      client_bootstrap_server_value_object := jsonb_build_object(
+        'securityMode', credentials_value::jsonb #> '{bootstrap,lwm2mServer}' ->> 'securityMode',
+        'clientPublicKeyOrId', client_public_key_or_id,
+        'clientSecretKey', client_secret_key
+        );
+      client_bootstrap_server_object := jsonb_build_object('lwm2mServer', client_bootstrap_server_value_object::jsonb);
+      client_bootstrap_object := credentials_value_new::jsonb #> '{bootstrap}' || client_bootstrap_server_object::jsonb;
+      credentials_value_new :=
+        jsonb_set(credentials_value_new::jsonb, '{bootstrap}', client_bootstrap_object::jsonb, false)::jsonb;
+    END IF;
+  END IF;
+
+  IF credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'securityMode' = 'RPK' OR
+     credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'securityMode' = 'X509' THEN
+    IF NULLIF(
+         (credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'clientSecretKey' ~ '^[0-9a-fA-F]+$')::text,
+         'false') = 'true' AND
+       NULLIF(
+         (credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'clientPublicKeyOrId' ~ '^[0-9a-fA-F]+$')::text,
+         'false') = 'true' THEN
+      client_secret_key :=
+        encode(
+          decode(credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'clientSecretKey', 'hex')::bytea,
+          'base64');
+      client_public_key_or_id := encode(
+        decode(credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'clientPublicKeyOrId', 'hex')::bytea,
+        'base64');
+      client_bootstrap_server_value_object := jsonb_build_object(
+        'securityMode', credentials_value::jsonb #> '{bootstrap,bootstrapServer}' ->> 'securityMode',
+        'clientPublicKeyOrId', client_public_key_or_id,
+        'clientSecretKey', client_secret_key
+        );
+      client_bootstrap_server_object :=
+        jsonb_build_object('bootstrapServer', client_bootstrap_server_value_object::jsonb);
+      client_bootstrap_object := credentials_value_new::jsonb #> '{bootstrap}' || client_bootstrap_server_object::jsonb;
+      credentials_value_new :=
+        jsonb_set(credentials_value_new::jsonb, '{bootstrap}', client_bootstrap_object::jsonb, false)::jsonb;
+    END IF;
+  END IF;
+
+END;
+$$;
\ No newline at end of file

application/src/main/data/upgrade/3.3.3/schema_event_ttl_procedure.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+
+DROP PROCEDURE IF EXISTS public.cleanup_events_by_ttl(bigint, bigint, bigint);
+
+CREATE OR REPLACE PROCEDURE cleanup_events_by_ttl(
+    IN regular_events_start_ts bigint,
+    IN regular_events_end_ts bigint,
+    IN debug_events_start_ts bigint,
+    IN debug_events_end_ts bigint,
+    INOUT deleted bigint)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    ttl_deleted_count bigint DEFAULT 0;
+    debug_ttl_deleted_count bigint DEFAULT 0;
+BEGIN
+    IF regular_events_start_ts > 0 AND regular_events_end_ts > 0 THEN
+        EXECUTE format(
+                'WITH deleted AS (DELETE FROM event WHERE id in (SELECT id from event WHERE ts > %L::bigint AND ts < %L::bigint AND ' ||
+                '(event_type != %L::varchar AND event_type != %L::varchar)) RETURNING *) ' ||
+                'SELECT count(*) FROM deleted', regular_events_start_ts, regular_events_end_ts,
+                'DEBUG_RULE_NODE', 'DEBUG_RULE_CHAIN') into ttl_deleted_count;
+    END IF;
+    IF debug_events_start_ts > 0 AND debug_events_end_ts > 0 THEN
+        EXECUTE format(
+                'WITH deleted AS (DELETE FROM event WHERE id in (SELECT id from event WHERE ts > %L::bigint AND ts < %L::bigint AND ' ||
+                '(event_type = %L::varchar OR event_type = %L::varchar)) RETURNING *) ' ||
+                'SELECT count(*) FROM deleted', debug_events_start_ts, debug_events_end_ts,
+                'DEBUG_RULE_NODE', 'DEBUG_RULE_CHAIN') into debug_ttl_deleted_count;
+    END IF;
+    RAISE NOTICE 'Events removed by ttl: %', ttl_deleted_count;
+    RAISE NOTICE 'Debug Events removed by ttl: %', debug_ttl_deleted_count;
+    deleted := ttl_deleted_count + debug_ttl_deleted_count;
+END
+$$;

application/src/main/data/upgrade/3.3.3/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+DELETE from ota_package as op WHERE NOT EXISTS(SELECT * FROM device_profile dp where op.device_profile_id = dp.id);
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'fk_device_profile_ota_package') THEN
+            ALTER TABLE ota_package
+                ADD CONSTRAINT fk_device_profile_ota_package
+                    FOREIGN KEY (device_profile_id) REFERENCES device_profile (id)
+                        ON DELETE CASCADE;
+        END IF;
+    END;
+$$;

application/src/main/data/upgrade/3.3.4/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+ALTER TABLE device
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE device_profile
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE asset
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE rule_chain
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE rule_node
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE dashboard
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE customer
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE widgets_bundle
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+ALTER TABLE entity_view
+    ADD COLUMN IF NOT EXISTS external_id UUID;
+
+CREATE INDEX IF NOT EXISTS idx_rule_node_external_id ON rule_node(rule_chain_id, external_id);
+CREATE INDEX IF NOT EXISTS idx_rule_node_type ON rule_node(type);
+
+ALTER TABLE admin_settings
+    ADD COLUMN IF NOT EXISTS tenant_id uuid NOT NULL DEFAULT '13814000-1dd2-11b2-8080-808080808080';
+
+CREATE TABLE IF NOT EXISTS queue (
+    id uuid NOT NULL CONSTRAINT queue_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid,
+    name varchar(255),
+    topic varchar(255),
+    poll_interval int,
+    partitions int,
+    consumer_per_partition boolean,
+    pack_processing_timeout bigint,
+    submit_strategy varchar(255),
+    processing_strategy varchar(255),
+    additional_info varchar
+);
+
+CREATE TABLE IF NOT EXISTS user_auth_settings (
+    id uuid NOT NULL CONSTRAINT user_auth_settings_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    user_id uuid UNIQUE NOT NULL CONSTRAINT fk_user_auth_settings_user_id REFERENCES tb_user(id),
+    two_fa_settings varchar
+);
+
+CREATE INDEX IF NOT EXISTS idx_api_usage_state_entity_id ON api_usage_state(entity_id);
+
+ALTER TABLE tenant_profile DROP COLUMN IF EXISTS isolated_tb_core;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'device_external_id_unq_key') THEN
+            ALTER TABLE device ADD CONSTRAINT device_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'device_profile_external_id_unq_key') THEN
+            ALTER TABLE device_profile ADD CONSTRAINT device_profile_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'asset_external_id_unq_key') THEN
+            ALTER TABLE asset ADD CONSTRAINT asset_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'rule_chain_external_id_unq_key') THEN
+            ALTER TABLE rule_chain ADD CONSTRAINT rule_chain_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'dashboard_external_id_unq_key') THEN
+            ALTER TABLE dashboard ADD CONSTRAINT dashboard_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'customer_external_id_unq_key') THEN
+            ALTER TABLE customer ADD CONSTRAINT customer_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'widgets_bundle_external_id_unq_key') THEN
+            ALTER TABLE widgets_bundle ADD CONSTRAINT widgets_bundle_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+
+DO
+$$
+    BEGIN
+        IF NOT EXISTS(SELECT 1 FROM pg_constraint WHERE conname = 'entity_view_external_id_unq_key') THEN
+            ALTER TABLE entity_view ADD CONSTRAINT entity_view_external_id_unq_key UNIQUE (tenant_id, external_id);
+        END IF;
+    END;
+$$;
+

application/src/main/data/upgrade/3.4.0/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS rule_node_debug_event (
+    id uuid NOT NULL,
+    tenant_id uuid NOT NULL ,
+    ts bigint NOT NULL,
+    entity_id uuid NOT NULL,
+    service_id varchar,
+    e_type varchar,
+    e_entity_id uuid,
+    e_entity_type varchar,
+    e_msg_id uuid,
+    e_msg_type varchar,
+    e_data_type varchar,
+    e_relation_type varchar,
+    e_data varchar,
+    e_metadata varchar,
+    e_error varchar
+) PARTITION BY RANGE (ts);
+
+CREATE TABLE IF NOT EXISTS rule_chain_debug_event (
+    id uuid NOT NULL,
+    tenant_id uuid NOT NULL,
+    ts bigint NOT NULL,
+    entity_id uuid NOT NULL,
+    service_id varchar NOT NULL,
+    e_message varchar,
+    e_error varchar
+) PARTITION BY RANGE (ts);
+
+CREATE TABLE IF NOT EXISTS stats_event (
+    id uuid NOT NULL,
+    tenant_id uuid NOT NULL,
+    ts bigint NOT NULL,
+    entity_id uuid NOT NULL,
+    service_id varchar NOT NULL,
+    e_messages_processed bigint NOT NULL,
+    e_errors_occurred bigint NOT NULL
+) PARTITION BY RANGE (ts);
+
+CREATE TABLE IF NOT EXISTS lc_event (
+    id uuid NOT NULL,
+    tenant_id uuid NOT NULL,
+    ts bigint NOT NULL,
+    entity_id uuid NOT NULL,
+    service_id varchar NOT NULL,
+    e_type varchar NOT NULL,
+    e_success boolean NOT NULL,
+    e_error varchar
+) PARTITION BY RANGE (ts);
+
+CREATE TABLE IF NOT EXISTS error_event (
+    id uuid NOT NULL,
+    tenant_id uuid NOT NULL,
+    ts bigint NOT NULL,
+    entity_id uuid NOT NULL,
+    service_id varchar NOT NULL,
+    e_method varchar NOT NULL,
+    e_error varchar
+) PARTITION BY RANGE (ts);
+
+CREATE INDEX IF NOT EXISTS idx_rule_node_debug_event_main
+    ON rule_node_debug_event (tenant_id ASC, entity_id ASC, ts DESC NULLS LAST) WITH (FILLFACTOR=95);
+
+CREATE INDEX IF NOT EXISTS idx_rule_chain_debug_event_main
+    ON rule_chain_debug_event (tenant_id ASC, entity_id ASC, ts DESC NULLS LAST) WITH (FILLFACTOR=95);
+
+CREATE INDEX IF NOT EXISTS idx_stats_event_main
+    ON stats_event (tenant_id ASC, entity_id ASC, ts DESC NULLS LAST) WITH (FILLFACTOR=95);
+
+CREATE INDEX IF NOT EXISTS idx_lc_event_main
+    ON lc_event (tenant_id ASC, entity_id ASC, ts DESC NULLS LAST) WITH (FILLFACTOR=95);
+
+CREATE INDEX IF NOT EXISTS idx_error_event_main
+    ON error_event (tenant_id ASC, entity_id ASC, ts DESC NULLS LAST) WITH (FILLFACTOR=95);
+
+CREATE OR REPLACE FUNCTION to_safe_json(p_json text) RETURNS json
+LANGUAGE plpgsql AS
+$$
+BEGIN
+  return REPLACE(p_json, '\u0000', '' )::json;
+EXCEPTION
+  WHEN OTHERS THEN
+  return '{}'::json;
+END;
+$$;
+
+-- Useful to migrate old events to the new table structure;
+CREATE OR REPLACE PROCEDURE migrate_regular_events(IN start_ts_in_ms bigint, IN end_ts_in_ms bigint, IN partition_size_in_hours int)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    partition_size_in_ms bigint;
+    p record;
+    table_name varchar;
+BEGIN
+    partition_size_in_ms = partition_size_in_hours * 3600 * 1000;
+
+    FOR p IN SELECT DISTINCT event_type as event_type, (created_time - created_time % partition_size_in_ms) as partition_ts FROM event e WHERE e.event_type in ('STATS', 'LC_EVENT', 'ERROR') and ts >= start_ts_in_ms and ts < end_ts_in_ms
+    LOOP
+        IF p.event_type = 'STATS' THEN
+            table_name := 'stats_event';
+        ELSEIF p.event_type = 'LC_EVENT' THEN
+            table_name := 'lc_event';
+        ELSEIF p.event_type = 'ERROR' THEN
+            table_name := 'error_event';
+        END IF;
+        RAISE NOTICE '[%] Partition to create : [%-%]', table_name, p.partition_ts, (p.partition_ts + partition_size_in_ms);
+        EXECUTE format('CREATE TABLE IF NOT EXISTS %s_%s PARTITION OF %s FOR VALUES FROM ( %s ) TO ( %s )', table_name, p.partition_ts, table_name, p.partition_ts, (p.partition_ts + partition_size_in_ms));
+    END LOOP;
+
+    INSERT INTO stats_event
+    SELECT id,
+           tenant_id,
+           ts,
+           entity_id,
+           body ->> 'server',
+           (body ->> 'messagesProcessed')::bigint,
+           (body ->> 'errorsOccurred')::bigint
+    FROM
+    (select id, tenant_id, ts, entity_id, to_safe_json(body) as body
+     FROM event WHERE ts >= start_ts_in_ms and ts < end_ts_in_ms AND event_type = 'STATS' AND to_safe_json(body) ->> 'server' IS NOT NULL
+    ) safe_event
+    ON CONFLICT DO NOTHING;
+
+    INSERT INTO lc_event
+    SELECT id,
+           tenant_id,
+           ts,
+           entity_id,
+           body ->> 'server',
+           body ->> 'event',
+           (body ->> 'success')::boolean,
+           body ->> 'error'
+    FROM
+    (select id, tenant_id, ts, entity_id, to_safe_json(body) as body
+     FROM event WHERE ts >= start_ts_in_ms and ts < end_ts_in_ms AND event_type = 'LC_EVENT' AND to_safe_json(body) ->> 'server' IS NOT NULL
+    ) safe_event
+    ON CONFLICT DO NOTHING;
+
+    INSERT INTO error_event
+    SELECT id,
+           tenant_id,
+           ts,
+           entity_id,
+           body ->> 'server',
+           body ->> 'method',
+           body ->> 'error'
+    FROM
+    (select id, tenant_id, ts, entity_id, to_safe_json(body) as body
+     FROM event WHERE ts >= start_ts_in_ms and ts < end_ts_in_ms AND event_type = 'ERROR' AND to_safe_json(body) ->> 'server' IS NOT NULL
+    ) safe_event
+    ON CONFLICT DO NOTHING;
+
+END
+$$;
+
+-- Useful to migrate old debug events to the new table structure;
+CREATE OR REPLACE PROCEDURE migrate_debug_events(IN start_ts_in_ms bigint, IN end_ts_in_ms bigint, IN partition_size_in_hours int)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    partition_size_in_ms bigint;
+    p record;
+    table_name varchar;
+BEGIN
+    partition_size_in_ms = partition_size_in_hours * 3600 * 1000;
+
+    FOR p IN SELECT DISTINCT event_type as event_type, (created_time - created_time % partition_size_in_ms) as partition_ts FROM event e WHERE e.event_type in ('DEBUG_RULE_NODE', 'DEBUG_RULE_CHAIN') and ts >= start_ts_in_ms and ts < end_ts_in_ms
+    LOOP
+        IF p.event_type = 'DEBUG_RULE_NODE' THEN
+            table_name := 'rule_node_debug_event';
+        ELSEIF p.event_type = 'DEBUG_RULE_CHAIN' THEN
+            table_name := 'rule_chain_debug_event';
+        END IF;
+        RAISE NOTICE '[%] Partition to create : [%-%]', table_name, p.partition_ts, (p.partition_ts + partition_size_in_ms);
+        EXECUTE format('CREATE TABLE IF NOT EXISTS %s_%s PARTITION OF %s FOR VALUES FROM ( %s ) TO ( %s )', table_name, p.partition_ts, table_name, p.partition_ts, (p.partition_ts + partition_size_in_ms));
+    END LOOP;
+
+    INSERT INTO rule_node_debug_event
+    SELECT id,
+           tenant_id,
+           ts,
+           entity_id,
+           body ->> 'server',
+           body ->> 'type',
+           (body ->> 'entityId')::uuid,
+           body ->> 'entityName',
+           (body ->> 'msgId')::uuid,
+           body ->> 'msgType',
+           body ->> 'dataType',
+           body ->> 'relationType',
+           body ->> 'data',
+           body ->> 'metadata',
+           body ->> 'error'
+    FROM
+    (select id, tenant_id, ts, entity_id, to_safe_json(body) as body
+     FROM event WHERE ts >= start_ts_in_ms and ts < end_ts_in_ms AND event_type = 'DEBUG_RULE_NODE' AND to_safe_json(body) ->> 'server' IS NOT NULL
+    ) safe_event
+    ON CONFLICT DO NOTHING;
+
+    INSERT INTO rule_chain_debug_event
+    SELECT id,
+           tenant_id,
+           ts,
+           entity_id,
+           body ->> 'server',
+           body ->> 'message',
+           body ->> 'error'
+    FROM
+    (select id, tenant_id, ts, entity_id, to_safe_json(body) as body
+     FROM event WHERE ts >= start_ts_in_ms and ts < end_ts_in_ms AND event_type = 'DEBUG_RULE_CHAIN' AND to_safe_json(body) ->> 'server' IS NOT NULL
+    ) safe_event
+    ON CONFLICT DO NOTHING;
+END
+$$;
+
+UPDATE tb_user
+    SET additional_info = REPLACE(additional_info, '"lang":"ja_JA"', '"lang":"ja_JP"')
+    WHERE additional_info LIKE '%"lang":"ja_JA"%';

application/src/main/data/upgrade/3.4.1/schema_update.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+-- AUDIT LOGS MIGRATION START
+DO
+$$
+    DECLARE table_partition RECORD;
+    BEGIN
+        -- in case of running the upgrade script a second time:
+        IF NOT (SELECT exists(SELECT FROM pg_tables WHERE tablename = 'old_audit_log')) THEN
+            ALTER TABLE audit_log RENAME TO old_audit_log;
+            CREATE INDEX IF NOT EXISTS idx_old_audit_log_created_time ON old_audit_log(created_time);
+
+            ALTER INDEX IF EXISTS idx_audit_log_tenant_id_and_created_time RENAME TO idx_old_audit_log_tenant_id_and_created_time;
+
+            FOR table_partition IN SELECT tablename AS name, split_part(tablename, '_', 3) AS partition_ts
+            FROM pg_tables WHERE tablename LIKE 'audit_log_%'
+            LOOP
+                EXECUTE format('ALTER TABLE %s RENAME TO old_audit_log_%s', table_partition.name, table_partition.partition_ts);
+            END LOOP;
+        ELSE
+            RAISE NOTICE 'Table old_audit_log already exists, leaving as is';
+        END IF;
+    END;
+$$;
+
+CREATE TABLE IF NOT EXISTS audit_log (
+    id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    tenant_id uuid,
+    customer_id uuid,
+    entity_id uuid,
+    entity_type varchar(255),
+    entity_name varchar(255),
+    user_id uuid,
+    user_name varchar(255),
+    action_type varchar(255),
+    action_data varchar(1000000),
+    action_status varchar(255),
+    action_failure_details varchar(1000000)
+) PARTITION BY RANGE (created_time);
+CREATE INDEX IF NOT EXISTS idx_audit_log_tenant_id_and_created_time ON audit_log(tenant_id, created_time DESC);
+CREATE INDEX IF NOT EXISTS idx_audit_log_id ON audit_log(id);
+
+CREATE OR REPLACE PROCEDURE migrate_audit_logs(IN start_time_ms BIGINT, IN end_time_ms BIGINT, IN partition_size_ms BIGINT)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    p RECORD;
+    partition_end_ts BIGINT;
+BEGIN
+    FOR p IN SELECT DISTINCT (created_time - created_time % partition_size_ms) AS partition_ts FROM old_audit_log
+    WHERE created_time >= start_time_ms AND created_time < end_time_ms
+    LOOP
+        partition_end_ts = p.partition_ts + partition_size_ms;
+        RAISE NOTICE '[audit_log] Partition to create : [%-%]', p.partition_ts, partition_end_ts;
+        EXECUTE format('CREATE TABLE IF NOT EXISTS audit_log_%s PARTITION OF audit_log ' ||
+         'FOR VALUES FROM ( %s ) TO ( %s )', p.partition_ts, p.partition_ts, partition_end_ts);
+    END LOOP;
+
+    INSERT INTO audit_log
+    SELECT id, created_time, tenant_id, customer_id, entity_id, entity_type, entity_name, user_id, user_name, action_type, action_data, action_status, action_failure_details
+    FROM old_audit_log
+    WHERE created_time >= start_time_ms AND created_time < end_time_ms;
+END;
+$$;
+-- AUDIT LOGS MIGRATION END
+
+
+-- EDGE EVENTS MIGRATION START
+DO
+$$
+    DECLARE table_partition RECORD;
+    BEGIN
+    -- in case of running the upgrade script a second time:
+        IF NOT (SELECT exists(SELECT FROM pg_tables WHERE tablename = 'old_edge_event')) THEN
+            ALTER TABLE edge_event RENAME TO old_edge_event;
+            CREATE INDEX IF NOT EXISTS idx_old_blob_entity_created_time_tmp ON old_blob_entity(created_time);
+            ALTER INDEX IF EXISTS idx_edge_event_tenant_id_and_created_time RENAME TO idx_old_edge_event_tenant_id_and_created_time;
+
+            FOR table_partition IN SELECT tablename AS name, split_part(tablename, '_', 3) AS partition_ts
+            FROM pg_tables WHERE tablename LIKE 'edge_event_%'
+            LOOP
+                EXECUTE format('ALTER TABLE %s RENAME TO old_edge_event_%s', table_partition.name, table_partition.partition_ts);
+            END LOOP;
+        ELSE
+            RAISE NOTICE 'Table old_edge_event already exists, leaving as is';
+        END IF;
+END;
+$$;
+
+CREATE TABLE IF NOT EXISTS edge_event (
+    id uuid NOT NULL,
+    created_time bigint NOT NULL,
+    edge_id uuid,
+    edge_event_type varchar(255),
+    edge_event_uid varchar(255),
+    entity_id uuid,
+    edge_event_action varchar(255),
+    body varchar(10000000),
+    tenant_id uuid,
+    ts bigint NOT NULL
+    ) PARTITION BY RANGE (created_time);
+CREATE INDEX IF NOT EXISTS idx_edge_event_tenant_id_and_created_time ON edge_event(tenant_id, created_time DESC);
+CREATE INDEX IF NOT EXISTS idx_edge_event_id ON edge_event(id);
+
+CREATE OR REPLACE PROCEDURE migrate_edge_event(IN start_time_ms BIGINT, IN end_time_ms BIGINT, IN partition_size_ms BIGINT)
+    LANGUAGE plpgsql AS
+$$
+DECLARE
+    p RECORD;
+    partition_end_ts BIGINT;
+BEGIN
+    FOR p IN SELECT DISTINCT (created_time - created_time % partition_size_ms) AS partition_ts FROM old_edge_event
+    WHERE created_time >= start_time_ms AND created_time < end_time_ms
+    LOOP
+        partition_end_ts = p.partition_ts + partition_size_ms;
+        RAISE NOTICE '[edge_event] Partition to create : [%-%]', p.partition_ts, partition_end_ts;
+        EXECUTE format('CREATE TABLE IF NOT EXISTS edge_event_%s PARTITION OF edge_event ' ||
+               'FOR VALUES FROM ( %s ) TO ( %s )', p.partition_ts, p.partition_ts, partition_end_ts);
+    END LOOP;
+
+    INSERT INTO edge_event
+    SELECT id, created_time, edge_id, edge_event_type, edge_event_uid, entity_id, edge_event_action, body, tenant_id, ts
+    FROM old_edge_event
+    WHERE created_time >= start_time_ms AND created_time < end_time_ms;
+END;
+$$;
+-- EDGE EVENTS MIGRATION END

application/src/main/data/upgrade/3.4.1/schema_update_after.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+DROP PROCEDURE IF EXISTS update_asset_profiles;
+
+ALTER TABLE asset ALTER COLUMN asset_profile_id SET NOT NULL;
+ALTER TABLE asset DROP CONSTRAINT IF EXISTS fk_asset_profile;
+ALTER TABLE asset ADD CONSTRAINT fk_asset_profile FOREIGN KEY (asset_profile_id) REFERENCES asset_profile(id);

application/src/main/data/upgrade/3.4.1/schema_update_before.sql

+--
+-- Copyright © 2016-2022 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE TABLE IF NOT EXISTS asset_profile (
+    id uuid NOT NULL CONSTRAINT asset_profile_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    name varchar(255),
+    image varchar(1000000),
+    description varchar,
+    search_text varchar(255),
+    is_default boolean,
+    tenant_id uuid,
+    default_rule_chain_id uuid,
+    default_dashboard_id uuid,
+    default_queue_name varchar(255),
+    external_id uuid,
+    CONSTRAINT asset_profile_name_unq_key UNIQUE (tenant_id, name),
+    CONSTRAINT asset_profile_external_id_unq_key UNIQUE (tenant_id, external_id),
+    CONSTRAINT fk_default_rule_chain_asset_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id),
+    CONSTRAINT fk_default_dashboard_asset_profile FOREIGN KEY (default_dashboard_id) REFERENCES dashboard(id)
+    );
+
+CREATE OR REPLACE PROCEDURE update_asset_profiles()
+    LANGUAGE plpgsql AS
+$$
+BEGIN
+    UPDATE asset a SET asset_profile_id = COALESCE(
+            (SELECT id from asset_profile p WHERE p.tenant_id = a.tenant_id AND a.type = p.name),
+            (SELECT id from asset_profile p WHERE p.tenant_id = a.tenant_id AND p.name = 'default')
+        )
+    WHERE a.asset_profile_id IS NULL;
+END;
+$$;

application/src/main/java/org/apache/kafka/common/network/NetworkReceive.java

+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Content of this file was modified to addresses the issue https://issues.apache.org/jira/browse/KAFKA-4090
+ *
+ */
+package org.apache.kafka.common.network;
+
+import org.apache.kafka.common.memory.MemoryPool;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.thingsboard.server.common.data.exception.ThingsboardKafkaClientError;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ScatteringByteChannel;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+/**
+ * A size delimited Receive that consists of a 4 byte network-ordered size N followed by N bytes of content
+ */
+public class NetworkReceive implements Receive {
+
+    public final static String UNKNOWN_SOURCE = "";
+    public final static int UNLIMITED = -1;
+    public final static int TB_MAX_REQUESTED_BUFFER_SIZE = 100 * 1024 * 1024;
+    public final static int TB_LOG_REQUESTED_BUFFER_SIZE = 10 * 1024 * 1024;
+    private static final Logger log = LoggerFactory.getLogger(NetworkReceive.class);
+    private static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);
+
+    private final String source;
+    private final ByteBuffer size;
+    private final int maxSize;
+    private final MemoryPool memoryPool;
+    private int requestedBufferSize = -1;
+    private ByteBuffer buffer;
+
+
+    public NetworkReceive(String source, ByteBuffer buffer) {
+        this.source = source;
+        this.buffer = buffer;
+        this.size = null;
+        this.maxSize = TB_MAX_REQUESTED_BUFFER_SIZE;
+        this.memoryPool = MemoryPool.NONE;
+    }
+
+    public NetworkReceive(String source) {
+        this.source = source;
+        this.size = ByteBuffer.allocate(4);
+        this.buffer = null;
+        this.maxSize = TB_MAX_REQUESTED_BUFFER_SIZE;
+        this.memoryPool = MemoryPool.NONE;
+    }
+
+    public NetworkReceive(int maxSize, String source) {
+        this.source = source;
+        this.size = ByteBuffer.allocate(4);
+        this.buffer = null;
+        this.maxSize = getMaxSize(maxSize);
+        this.memoryPool = MemoryPool.NONE;
+    }
+
+    public NetworkReceive(int maxSize, String source, MemoryPool memoryPool) {
+        this.source = source;
+        this.size = ByteBuffer.allocate(4);
+        this.buffer = null;
+        this.maxSize = getMaxSize(maxSize);
+        this.memoryPool = memoryPool;
+    }
+
+    public NetworkReceive() {
+        this(UNKNOWN_SOURCE);
+    }
+
+    @Override
+    public String source() {
+        return source;
+    }
+
+    @Override
+    public boolean complete() {
+        return !size.hasRemaining() && buffer != null && !buffer.hasRemaining();
+    }
+
+    public long readFrom(ScatteringByteChannel channel) throws IOException {
+        int read = 0;
+        if (size.hasRemaining()) {
+            int bytesRead = channel.read(size);
+            if (bytesRead < 0)
+                throw new EOFException();
+            read += bytesRead;
+            if (!size.hasRemaining()) {
+                size.rewind();
+                int receiveSize = size.getInt();
+                if (receiveSize < 0)
+                    throw new InvalidReceiveException("Invalid receive (size = " + receiveSize + ")");
+                if (maxSize != UNLIMITED && receiveSize > maxSize) {
+                    throw new ThingsboardKafkaClientError("Invalid receive (size = " + receiveSize + " larger than " + maxSize + ")");
+                }
+                requestedBufferSize = receiveSize; //may be 0 for some payloads (SASL)
+                if (receiveSize == 0) {
+                    buffer = EMPTY_BUFFER;
+                }
+            }
+        }
+        if (buffer == null && requestedBufferSize != -1) { //we know the size we want but havent been able to allocate it yet
+            if (requestedBufferSize > TB_LOG_REQUESTED_BUFFER_SIZE) {
+                String stackTrace = Arrays.stream(Thread.currentThread().getStackTrace()).map(StackTraceElement::toString).collect(Collectors.joining("|"));
+                log.error("Allocating buffer of size {} for source {}", requestedBufferSize, source);
+                log.error("Stack Trace: {}", stackTrace);
+            }
+            buffer = memoryPool.tryAllocate(requestedBufferSize);
+            if (buffer == null)
+                log.trace("Broker low on memory - could not allocate buffer of size {} for source {}", requestedBufferSize, source);
+        }
+        if (buffer != null) {
+            int bytesRead = channel.read(buffer);
+            if (bytesRead < 0)
+                throw new EOFException();
+            read += bytesRead;
+        }
+
+        return read;
+    }
+
+    @Override
+    public boolean requiredMemoryAmountKnown() {
+        return requestedBufferSize != -1;
+    }
+
+    @Override
+    public boolean memoryAllocated() {
+        return buffer != null;
+    }
+
+
+    @Override
+    public void close() throws IOException {
+        if (buffer != null && buffer != EMPTY_BUFFER) {
+            memoryPool.release(buffer);
+            buffer = null;
+        }
+    }
+
+    public ByteBuffer payload() {
+        return this.buffer;
+    }
+
+    public int bytesRead() {
+        if (buffer == null)
+            return size.position();
+        return buffer.position() + size.position();
+    }
+
+    /**
+     * Returns the total size of the receive including payload and size buffer
+     * for use in metrics. This is consistent with {@link NetworkSend#size()}
+     */
+    public int size() {
+        return payload().limit() + size.limit();
+    }
+
+    private int getMaxSize(int maxSize) {
+        return maxSize == UNLIMITED ? TB_MAX_REQUESTED_BUFFER_SIZE : Math.min(maxSize, TB_MAX_REQUESTED_BUFFER_SIZE);
+    }
+
+}

application/src/main/java/org/thingsboard/server/ThingsboardInstallApplication.java

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.SpringBootConfiguration;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.ComponentScan;
+import org.thingsboard.server.install.ThingsboardInstallService;
+
+import java.util.Arrays;
+
+@Slf4j
+@SpringBootConfiguration
+@ComponentScan({"org.thingsboard.server.install",
+        "org.thingsboard.server.service.component",
+        "org.thingsboard.server.service.install",
+        "org.thingsboard.server.service.security.auth.jwt.settings",
+        "org.thingsboard.server.dao",
+        "org.thingsboard.server.common.stats",
+        "org.thingsboard.server.common.transport.config.ssl",
+        "org.thingsboard.server.cache",
+        "org.thingsboard.server.springfox"
+})
+public class ThingsboardInstallApplication {
+
+    private static final String SPRING_CONFIG_NAME_KEY = "--spring.config.name";
+    private static final String DEFAULT_SPRING_CONFIG_PARAM = SPRING_CONFIG_NAME_KEY + "=" + "thingsboard";
+
+    public static void main(String[] args) {
+        try {
+            SpringApplication application = new SpringApplication(ThingsboardInstallApplication.class);
+            application.setAdditionalProfiles("install");
+            ConfigurableApplicationContext context = application.run(updateArguments(args));
+            context.getBean(ThingsboardInstallService.class).performInstall();
+        } catch (Exception e) {
+            log.error(e.getMessage());
+            System.exit(1);
+        }
+    }
+
+    private static String[] updateArguments(String[] args) {
+        if (Arrays.stream(args).noneMatch(arg -> arg.startsWith(SPRING_CONFIG_NAME_KEY))) {
+            String[] modifiedArgs = new String[args.length + 1];
+            System.arraycopy(args, 0, modifiedArgs, 0, args.length);
+            modifiedArgs[args.length] = DEFAULT_SPRING_CONFIG_PARAM;
+            return modifiedArgs;
+        }
+        return args;
+    }
+}

application/src/main/java/org/thingsboard/server/ThingsboardServerApplication.java

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.SpringBootConfiguration;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+import java.util.Arrays;
+
+@SpringBootConfiguration
+@EnableAsync
+@EnableScheduling
+@ComponentScan({"org.thingsboard.server", "org.thingsboard.script"})
+public class ThingsboardServerApplication {
+
+    private static final String SPRING_CONFIG_NAME_KEY = "--spring.config.name";
+    private static final String DEFAULT_SPRING_CONFIG_PARAM = SPRING_CONFIG_NAME_KEY + "=" + "thingsboard";
+
+    public static void main(String[] args) {
+        SpringApplication.run(ThingsboardServerApplication.class, updateArguments(args));
+    }
+
+    private static String[] updateArguments(String[] args) {
+        if (Arrays.stream(args).noneMatch(arg -> arg.startsWith(SPRING_CONFIG_NAME_KEY))) {
+            String[] modifiedArgs = new String[args.length + 1];
+            System.arraycopy(args, 0, modifiedArgs, 0, args.length);
+            modifiedArgs[args.length] = DEFAULT_SPRING_CONFIG_PARAM;
+            return modifiedArgs;
+        }
+        return args;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.thingsboard.rule.engine.api.MailService;
+import org.thingsboard.rule.engine.api.SmsService;
+import org.thingsboard.rule.engine.api.sms.SmsSenderFactory;
+import org.thingsboard.script.api.js.JsInvokeService;
+import org.thingsboard.script.api.tbel.TbelInvokeService;
+import org.thingsboard.server.actors.service.ActorService;
+import org.thingsboard.server.actors.tenant.DebugTbRateLimits;
+import org.thingsboard.server.cluster.TbClusterService;
+import org.thingsboard.server.common.data.event.ErrorEvent;
+import org.thingsboard.server.common.data.event.LifecycleEvent;
+import org.thingsboard.server.common.data.event.RuleChainDebugEvent;
+import org.thingsboard.server.common.data.event.RuleNodeDebugEvent;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.msg.TbActorMsg;
+import org.thingsboard.server.common.msg.TbMsg;
+import org.thingsboard.server.common.msg.queue.ServiceType;
+import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
+import org.thingsboard.server.common.msg.tools.TbRateLimits;
+import org.thingsboard.server.common.stats.TbApiUsageReportClient;
+import org.thingsboard.server.dao.asset.AssetProfileService;
+import org.thingsboard.server.dao.asset.AssetService;
+import org.thingsboard.server.dao.attributes.AttributesService;
+import org.thingsboard.server.dao.audit.AuditLogService;
+import org.thingsboard.server.dao.cassandra.CassandraCluster;
+import org.thingsboard.server.dao.customer.CustomerService;
+import org.thingsboard.server.dao.dashboard.DashboardService;
+import org.thingsboard.server.dao.device.ClaimDevicesService;
+import org.thingsboard.server.dao.device.DeviceCredentialsService;
+import org.thingsboard.server.dao.device.DeviceProfileService;
+import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.edge.EdgeEventService;
+import org.thingsboard.server.dao.edge.EdgeService;
+import org.thingsboard.server.dao.entityview.EntityViewService;
+import org.thingsboard.server.dao.event.EventService;
+import org.thingsboard.server.dao.nosql.CassandraBufferedRateReadExecutor;
+import org.thingsboard.server.dao.nosql.CassandraBufferedRateWriteExecutor;
+import org.thingsboard.server.dao.ota.OtaPackageService;
+import org.thingsboard.server.dao.queue.QueueService;
+import org.thingsboard.server.dao.relation.RelationService;
+import org.thingsboard.server.dao.resource.ResourceService;
+import org.thingsboard.server.dao.rule.RuleChainService;
+import org.thingsboard.server.dao.rule.RuleNodeStateService;
+import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
+import org.thingsboard.server.dao.tenant.TenantProfileService;
+import org.thingsboard.server.dao.tenant.TenantService;
+import org.thingsboard.server.dao.timeseries.TimeseriesService;
+import org.thingsboard.server.dao.user.UserService;
+import org.thingsboard.server.dao.widget.WidgetTypeService;
+import org.thingsboard.server.dao.widget.WidgetsBundleService;
+import org.thingsboard.server.queue.discovery.PartitionService;
+import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;
+import org.thingsboard.server.queue.util.DataDecodingEncodingService;
+import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
+import org.thingsboard.server.service.component.ComponentDiscoveryService;
+import org.thingsboard.server.service.edge.rpc.EdgeRpcService;
+import org.thingsboard.server.service.entitiy.entityview.TbEntityViewService;
+import org.thingsboard.server.service.executors.DbCallbackExecutorService;
+import org.thingsboard.server.service.executors.ExternalCallExecutorService;
+import org.thingsboard.server.service.executors.SharedEventLoopGroupService;
+import org.thingsboard.server.service.mail.MailExecutorService;
+import org.thingsboard.server.service.profile.TbAssetProfileCache;
+import org.thingsboard.server.service.profile.TbDeviceProfileCache;
+import org.thingsboard.server.service.rpc.TbCoreDeviceRpcService;
+import org.thingsboard.server.service.rpc.TbRpcService;
+import org.thingsboard.server.service.rpc.TbRuleEngineDeviceRpcService;
+import org.thingsboard.server.service.session.DeviceSessionCacheService;
+import org.thingsboard.server.service.sms.SmsExecutorService;
+import org.thingsboard.server.service.state.DeviceStateService;
+import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
+import org.thingsboard.server.service.telemetry.TelemetrySubscriptionService;
+import org.thingsboard.server.service.transport.TbCoreToTransportService;
+
+import javax.annotation.Nullable;
+import javax.annotation.PostConstruct;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@Component
+public class ActorSystemContext {
+
+    private static final FutureCallback<Void> RULE_CHAIN_DEBUG_EVENT_ERROR_CALLBACK = new FutureCallback<>() {
+        @Override
+        public void onSuccess(@Nullable Void event) {
+
+        }
+
+        @Override
+        public void onFailure(Throwable th) {
+            log.error("Could not save debug Event for Rule Chain", th);
+        }
+    };
+    private static final FutureCallback<Void> RULE_NODE_DEBUG_EVENT_ERROR_CALLBACK = new FutureCallback<>() {
+        @Override
+        public void onSuccess(@Nullable Void event) {
+
+        }
+
+        @Override
+        public void onFailure(Throwable th) {
+            log.error("Could not save debug Event for Node", th);
+        }
+    };
+
+    protected final ObjectMapper mapper = new ObjectMapper();
+
+    private final ConcurrentMap<TenantId, DebugTbRateLimits> debugPerTenantLimits = new ConcurrentHashMap<>();
+
+    public ConcurrentMap<TenantId, DebugTbRateLimits> getDebugPerTenantLimits() {
+        return debugPerTenantLimits;
+    }
+
+    @Autowired
+    @Getter
+    private TbApiUsageStateService apiUsageStateService;
+
+    @Autowired
+    @Getter
+    private TbApiUsageReportClient apiUsageClient;
+
+    @Autowired
+    @Getter
+    @Setter
+    private TbServiceInfoProvider serviceInfoProvider;
+
+    @Getter
+    @Setter
+    private ActorService actorService;
+
+    @Autowired
+    @Getter
+    @Setter
+    private ComponentDiscoveryService componentService;
+
+    @Autowired
+    @Getter
+    private DataDecodingEncodingService encodingService;
+
+    @Autowired
+    @Getter
+    private DeviceService deviceService;
+
+    @Autowired
+    @Getter
+    private DeviceProfileService deviceProfileService;
+
+    @Autowired
+    @Getter
+    private AssetProfileService assetProfileService;
+
+    @Autowired
+    @Getter
+    private DeviceCredentialsService deviceCredentialsService;
+
+    @Autowired
+    @Getter
+    private TbTenantProfileCache tenantProfileCache;
+
+    @Autowired
+    @Getter
+    private TbDeviceProfileCache deviceProfileCache;
+
+    @Autowired
+    @Getter
+    private TbAssetProfileCache assetProfileCache;
+
+    @Autowired
+    @Getter
+    private AssetService assetService;
+
+    @Autowired
+    @Getter
+    private DashboardService dashboardService;
+
+    @Autowired
+    @Getter
+    private TenantService tenantService;
+
+    @Autowired
+    @Getter
+    private TenantProfileService tenantProfileService;
+
+    @Autowired
+    @Getter
+    private CustomerService customerService;
+
+    @Autowired
+    @Getter
+    private UserService userService;
+
+    @Autowired
+    @Getter
+    private RuleChainService ruleChainService;
+
+    @Autowired
+    @Getter
+    private RuleNodeStateService ruleNodeStateService;
+
+    @Autowired
+    private PartitionService partitionService;
+
+    @Autowired
+    @Getter
+    private TbClusterService clusterService;
+
+    @Autowired
+    @Getter
+    private TimeseriesService tsService;
+
+    @Autowired
+    @Getter
+    private AttributesService attributesService;
+
+    @Autowired
+    @Getter
+    private EventService eventService;
+
+    @Autowired
+    @Getter
+    private RelationService relationService;
+
+    @Autowired
+    @Getter
+    private AuditLogService auditLogService;
+
+    @Autowired
+    @Getter
+    private EntityViewService entityViewService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private TbEntityViewService tbEntityViewService;
+
+    @Autowired
+    @Getter
+    private TelemetrySubscriptionService tsSubService;
+
+    @Autowired
+    @Getter
+    private AlarmSubscriptionService alarmService;
+
+    @Autowired
+    @Getter
+    private JsInvokeService jsInvokeService;
+
+    @Autowired(required = false)
+    @Getter
+    private TbelInvokeService tbelInvokeService;
+
+    @Autowired
+    @Getter
+    private MailExecutorService mailExecutor;
+
+    @Autowired
+    @Getter
+    private SmsExecutorService smsExecutor;
+
+    @Autowired
+    @Getter
+    private DbCallbackExecutorService dbCallbackExecutor;
+
+    @Autowired
+    @Getter
+    private ExternalCallExecutorService externalCallExecutorService;
+
+    @Autowired
+    @Getter
+    private SharedEventLoopGroupService sharedEventLoopGroupService;
+
+    @Autowired
+    @Getter
+    private MailService mailService;
+
+    @Autowired
+    @Getter
+    private SmsService smsService;
+
+    @Autowired
+    @Getter
+    private SmsSenderFactory smsSenderFactory;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private ClaimDevicesService claimDevicesService;
+
+    @Autowired
+    @Getter
+    private JsInvokeStats jsInvokeStats;
+
+    //TODO: separate context for TbCore and TbRuleEngine
+    @Autowired(required = false)
+    @Getter
+    private DeviceStateService deviceStateService;
+
+    @Autowired(required = false)
+    @Getter
+    private DeviceSessionCacheService deviceSessionCacheService;
+
+    @Autowired(required = false)
+    @Getter
+    private TbCoreToTransportService tbCoreToTransportService;
+
+    /**
+     * The following Service will be null if we operate in tb-core mode
+     */
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private TbRuleEngineDeviceRpcService tbRuleEngineDeviceRpcService;
+
+    /**
+     * The following Service will be null if we operate in tb-rule-engine mode
+     */
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private TbCoreDeviceRpcService tbCoreDeviceRpcService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private EdgeService edgeService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private EdgeEventService edgeEventService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private EdgeRpcService edgeRpcService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private ResourceService resourceService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private OtaPackageService otaPackageService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private TbRpcService tbRpcService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private QueueService queueService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private WidgetsBundleService widgetsBundleService;
+
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private WidgetTypeService widgetTypeService;
+
+    @Value("${actors.session.max_concurrent_sessions_per_device:1}")
+    @Getter
+    private long maxConcurrentSessionsPerDevice;
+
+    @Value("${actors.session.sync.timeout:10000}")
+    @Getter
+    private long syncSessionTimeout;
+
+    @Value("${actors.rule.chain.error_persist_frequency:3000}")
+    @Getter
+    private long ruleChainErrorPersistFrequency;
+
+    @Value("${actors.rule.node.error_persist_frequency:3000}")
+    @Getter
+    private long ruleNodeErrorPersistFrequency;
+
+    @Value("${actors.statistics.enabled:true}")
+    @Getter
+    private boolean statisticsEnabled;
+
+    @Value("${actors.statistics.persist_frequency:3600000}")
+    @Getter
+    private long statisticsPersistFrequency;
+
+    @Value("${edges.enabled:true}")
+    @Getter
+    private boolean edgesEnabled;
+
+    @Value("${cache.type:caffeine}")
+    @Getter
+    private String cacheType;
+
+    @Getter
+    private boolean localCacheType;
+
+    @PostConstruct
+    public void init() {
+        this.localCacheType = "caffeine".equals(cacheType);
+    }
+
+    @Scheduled(fixedDelayString = "${actors.statistics.js_print_interval_ms}")
+    public void printStats() {
+        if (statisticsEnabled) {
+            if (jsInvokeStats.getRequests() > 0 || jsInvokeStats.getResponses() > 0 || jsInvokeStats.getFailures() > 0) {
+                log.info("Rule Engine JS Invoke Stats: requests [{}] responses [{}] failures [{}]",
+                        jsInvokeStats.getRequests(), jsInvokeStats.getResponses(), jsInvokeStats.getFailures());
+                jsInvokeStats.reset();
+            }
+        }
+    }
+
+    @Value("${actors.tenant.create_components_on_init:true}")
+    @Getter
+    private boolean tenantComponentsInitEnabled;
+
+    @Value("${actors.rule.allow_system_mail_service:true}")
+    @Getter
+    private boolean allowSystemMailService;
+
+    @Value("${actors.rule.allow_system_sms_service:true}")
+    @Getter
+    private boolean allowSystemSmsService;
+
+    @Value("${transport.sessions.inactivity_timeout:300000}")
+    @Getter
+    private long sessionInactivityTimeout;
+
+    @Value("${transport.sessions.report_timeout:3000}")
+    @Getter
+    private long sessionReportTimeout;
+
+    @Value("${actors.rule.chain.debug_mode_rate_limits_per_tenant.enabled:true}")
+    @Getter
+    private boolean debugPerTenantEnabled;
+
+    @Value("${actors.rule.chain.debug_mode_rate_limits_per_tenant.configuration:50000:3600}")
+    @Getter
+    private String debugPerTenantLimitsConfiguration;
+
+    @Value("${actors.rpc.sequential:false}")
+    @Getter
+    private boolean rpcSequential;
+
+    @Value("${actors.rpc.max_retries:5}")
+    @Getter
+    private int maxRpcRetries;
+
+    @Getter
+    @Setter
+    private TbActorSystem actorSystem;
+
+    @Setter
+    private TbActorRef appActor;
+
+    @Getter
+    @Setter
+    private TbActorRef statsActor;
+
+    @Autowired(required = false)
+    @Getter
+    private CassandraCluster cassandraCluster;
+
+    @Autowired(required = false)
+    @Getter
+    private CassandraBufferedRateReadExecutor cassandraBufferedRateReadExecutor;
+
+    @Autowired(required = false)
+    @Getter
+    private CassandraBufferedRateWriteExecutor cassandraBufferedRateWriteExecutor;
+
+    @Autowired(required = false)
+    @Getter
+    private RedisTemplate<String, Object> redisTemplate;
+
+    public ScheduledExecutorService getScheduler() {
+        return actorSystem.getScheduler();
+    }
+
+    public void persistError(TenantId tenantId, EntityId entityId, String method, Exception e) {
+        eventService.saveAsync(ErrorEvent.builder()
+                .tenantId(tenantId)
+                .entityId(entityId.getId())
+                .serviceId(getServiceId())
+                .method(method)
+                .error(toString(e)).build());
+    }
+
+    public void persistLifecycleEvent(TenantId tenantId, EntityId entityId, ComponentLifecycleEvent lcEvent, Exception e) {
+        LifecycleEvent.LifecycleEventBuilder event = LifecycleEvent.builder()
+                .tenantId(tenantId)
+                .entityId(entityId.getId())
+                .serviceId(getServiceId())
+                .lcEventType(lcEvent.name());
+
+        if (e != null) {
+            event.success(false).error(toString(e));
+        } else {
+            event.success(true);
+        }
+
+        eventService.saveAsync(event.build());
+    }
+
+    private String toString(Throwable e) {
+        StringWriter sw = new StringWriter();
+        e.printStackTrace(new PrintWriter(sw));
+        return sw.toString();
+    }
+
+    public TopicPartitionInfo resolve(ServiceType serviceType, TenantId tenantId, EntityId entityId) {
+        return partitionService.resolve(serviceType, tenantId, entityId);
+    }
+
+    public TopicPartitionInfo resolve(ServiceType serviceType, String queueName, TenantId tenantId, EntityId entityId) {
+        return partitionService.resolve(serviceType, queueName, tenantId, entityId);
+    }
+
+    public String getServiceId() {
+        return serviceInfoProvider.getServiceId();
+    }
+
+    public void persistDebugInput(TenantId tenantId, EntityId entityId, TbMsg tbMsg, String relationType) {
+        persistDebugAsync(tenantId, entityId, "IN", tbMsg, relationType, null, null);
+    }
+
+    public void persistDebugInput(TenantId tenantId, EntityId entityId, TbMsg tbMsg, String relationType, Throwable error) {
+        persistDebugAsync(tenantId, entityId, "IN", tbMsg, relationType, error, null);
+    }
+
+    public void persistDebugOutput(TenantId tenantId, EntityId entityId, TbMsg tbMsg, String relationType, Throwable error, String failureMessage) {
+        persistDebugAsync(tenantId, entityId, "OUT", tbMsg, relationType, error, failureMessage);
+    }
+
+    public void persistDebugOutput(TenantId tenantId, EntityId entityId, TbMsg tbMsg, String relationType, Throwable error) {
+        persistDebugAsync(tenantId, entityId, "OUT", tbMsg, relationType, error, null);
+    }
+
+    public void persistDebugOutput(TenantId tenantId, EntityId entityId, TbMsg tbMsg, String relationType) {
+        persistDebugAsync(tenantId, entityId, "OUT", tbMsg, relationType, null, null);
+    }
+
+    private void persistDebugAsync(TenantId tenantId, EntityId entityId, String type, TbMsg tbMsg, String relationType, Throwable error, String failureMessage) {
+        if (checkLimits(tenantId, tbMsg, error)) {
+            try {
+                RuleNodeDebugEvent.RuleNodeDebugEventBuilder event = RuleNodeDebugEvent.builder()
+                        .tenantId(tenantId)
+                        .entityId(entityId.getId())
+                        .serviceId(getServiceId())
+                        .eventType(type)
+                        .eventEntity(tbMsg.getOriginator())
+                        .msgId(tbMsg.getId())
+                        .msgType(tbMsg.getType())
+                        .dataType(tbMsg.getDataType().name())
+                        .relationType(relationType)
+                        .data(tbMsg.getData())
+                        .metadata(mapper.writeValueAsString(tbMsg.getMetaData().getData()));
+
+                if (error != null) {
+                    event.error(toString(error));
+                } else if (failureMessage != null) {
+                    event.error(failureMessage);
+                }
+
+                ListenableFuture<Void> future = eventService.saveAsync(event.build());
+                Futures.addCallback(future, RULE_NODE_DEBUG_EVENT_ERROR_CALLBACK, MoreExecutors.directExecutor());
+            } catch (IOException ex) {
+                log.warn("Failed to persist rule node debug message", ex);
+            }
+        }
+    }
+
+    private boolean checkLimits(TenantId tenantId, TbMsg tbMsg, Throwable error) {
+        if (debugPerTenantEnabled) {
+            DebugTbRateLimits debugTbRateLimits = debugPerTenantLimits.computeIfAbsent(tenantId, id ->
+                    new DebugTbRateLimits(new TbRateLimits(debugPerTenantLimitsConfiguration), false));
+
+            if (!debugTbRateLimits.getTbRateLimits().tryConsume()) {
+                if (!debugTbRateLimits.isRuleChainEventSaved()) {
+                    persistRuleChainDebugModeEvent(tenantId, tbMsg.getRuleChainId(), error);
+                    debugTbRateLimits.setRuleChainEventSaved(true);
+                }
+                if (log.isTraceEnabled()) {
+                    log.trace("[{}] Tenant level debug mode rate limit detected: {}", tenantId, tbMsg);
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void persistRuleChainDebugModeEvent(TenantId tenantId, EntityId entityId, Throwable error) {
+        RuleChainDebugEvent.RuleChainDebugEventBuilder event = RuleChainDebugEvent.builder()
+                .tenantId(tenantId)
+                .entityId(entityId.getId())
+                .serviceId(getServiceId())
+                .message("Reached debug mode rate limit!");
+        if (error != null) {
+            event.error(toString(error));
+        }
+
+        ListenableFuture<Void> future = eventService.saveAsync(event.build());
+        Futures.addCallback(future, RULE_CHAIN_DEBUG_EVENT_ERROR_CALLBACK, MoreExecutors.directExecutor());
+    }
+
+    public static Exception toException(Throwable error) {
+        return Exception.class.isInstance(error) ? (Exception) error : new Exception(error);
+    }
+
+    public void tell(TbActorMsg tbActorMsg) {
+        appActor.tell(tbActorMsg);
+    }
+
+    public void tellWithHighPriority(TbActorMsg tbActorMsg) {
+        appActor.tellWithHighPriority(tbActorMsg);
+    }
+
+    public void schedulePeriodicMsgWithDelay(TbActorRef ctx, TbActorMsg msg, long delayInMs, long periodInMs) {
+        log.debug("Scheduling periodic msg {} every {} ms with delay {} ms", msg, periodInMs, delayInMs);
+        getScheduler().scheduleWithFixedDelay(() -> ctx.tell(msg), delayInMs, periodInMs, TimeUnit.MILLISECONDS);
+    }
+
+    public void scheduleMsgWithDelay(TbActorRef ctx, TbActorMsg msg, long delayInMs) {
+        log.debug("Scheduling msg {} with delay {} ms", msg, delayInMs);
+        if (delayInMs > 0) {
+            getScheduler().schedule(() -> ctx.tell(msg), delayInMs, TimeUnit.MILLISECONDS);
+        } else {
+            ctx.tell(msg);
+        }
+    }
+
+}